// required for old g++ to compile PRId64 macros, see // https://github.com/pytorch/pytorch/issues/3571 // for context #ifndef __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS #endif // an external backend might generate file within its code tree // and check all the source files within the tree with clang-format. // so, disable it since the backend might have a different config. // clang-format off // NOTE: This condition is true for all PyTorch internal libraries, it // just excludes external projects such as torch_xla which // re-use some of the PyTorch codegen machinery. #if defined(CAFFE2_BUILD_MAIN_LIB) || \ defined(TORCH_CUDA_BUILD_MAIN_LIB) || \ defined(TORCH_HIP_BUILD_MAIN_LIB) || \ defined(TORCH_XPU_BUILD_MAIN_LIB) || \ defined(TORCH_CUDA_CU_BUILD_MAIN_LIB) || \ defined(TORCH_CUDA_CPP_BUILD_MAIN_LIB) #define TORCH_ASSERT_ONLY_METHOD_OPERATORS #endif // @generated by torchgen/gen.py from RegisterDispatchKey.cpp #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace at { namespace { C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function") Tensor create_out(IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) { if (strides.empty()) { return at::detail::empty_meta(sizes, options.device(at::kMeta)); } else { return at::detail::empty_strided_meta(sizes, strides, options.device(at::kMeta)); } } void resize_out(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) { TORCH_CHECK(options.dtype() == out.dtype(), "Expected out tensor to have dtype ", options.dtype(), ", but got ", out.dtype(), " instead"); TORCH_CHECK(options.device() == out.device(), "Expected out tensor to have device ", options.device(), ", but got ", out.device(), " instead"); const bool resized = at::native::resize_output(out, sizes); // Only restride if a resize occurred; otherwise we ignore the (advisory) // strides from the meta function and directly use the output tensor's // preexisting strides if (resized) { if (!strides.empty()) { TORCH_INTERNAL_ASSERT(!options.memory_format_opt().has_value()); // TODO: avoid the redispatch here out.as_strided_(sizes, strides); } else if (options.memory_format_opt().has_value()) { out.unsafeGetTensorImpl()->empty_tensor_restride(*options.memory_format_opt()); } } } void check_inplace(const Tensor &self, IntArrayRef sizes, const TensorOptions &options) { // These checks are needed on those operators that: // 1) don't use 'TensorIterator' (e.g. 'addmm' and 'baddbmm') // 2) have particular typing rules (e.g. 'cumsum' and 'cumprod') // For other operators (e.g. 'add'), 'TensorIterator' already checks // these things separately. TORCH_CHECK(options.dtype() == self.dtype(), "Bad in-place call: ", "input tensor dtype ", self.dtype(), " and output tensor dtype ", options.dtype(), " should match"); TORCH_CHECK(options.device() == self.device(), "Bad in-place call: ", "input tensor device ", self.device(), " and output tensor device ", options.device(), " should match"); TORCH_CHECK(sizes == self.sizes(), "Bad in-place call: ", "input tensor size ", self.sizes(), " and output tensor size ", sizes, " should match"); } std::optional maybe_create_proxy(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) { if (out.strides() != strides) { return at::detail::empty_strided_meta(sizes, strides, options); } return std::nullopt; } C10_DIAGNOSTIC_POP() } // namespace } // namespace at // See template file RegisterDispatchDefinitions.ini namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { void wrapper_Meta___assert_tensor_metadata(const at::Tensor & a, at::OptionalSymIntArrayRef size, at::OptionalSymIntArrayRef stride, ::std::optional dtype, ::std::optional device, ::std::optional layout) { // No device check // DeviceGuard omitted return at::native::_assert_tensor_metadata_meta_symint(a, size, stride, dtype, device, layout); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_assert_tensor_metadata", TORCH_FN(wrapper_Meta___assert_tensor_metadata)); } } // anonymous namespace namespace meta { void _assert_tensor_metadata(const at::Tensor & a, at::OptionalIntArrayRef size, at::OptionalIntArrayRef stride, ::std::optional dtype, ::std::optional device, ::std::optional layout) { return wrapper_Meta___assert_tensor_metadata(a, size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*size)) : ::std::nullopt, stride.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*stride)) : ::std::nullopt, dtype, device, layout); } void _assert_tensor_metadata_symint(const at::Tensor & a, at::OptionalSymIntArrayRef size, at::OptionalSymIntArrayRef stride, ::std::optional dtype, ::std::optional device, ::std::optional layout) { return wrapper_Meta___assert_tensor_metadata(a, size, stride, dtype, device, layout); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__view_as_real(const at::Tensor & self) { // No device check // DeviceGuard omitted return at::native::view_as_real(self); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("view_as_real", TORCH_FN(wrapper_Meta__view_as_real)); } } // anonymous namespace namespace meta { at::Tensor view_as_real(const at::Tensor & self) { return wrapper_Meta__view_as_real(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__view_as_complex(const at::Tensor & self) { // No device check // DeviceGuard omitted return at::native::view_as_complex(self); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("view_as_complex", TORCH_FN(wrapper_Meta__view_as_complex)); } } // anonymous namespace namespace meta { at::Tensor view_as_complex(const at::Tensor & self) { return wrapper_Meta__view_as_complex(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sgn_meta_functional final : public at::meta::structured_sgn { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sgn(const at::Tensor & self) { structured_sgn_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sgn_meta_out final : public at::meta::structured_sgn { structured_sgn_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sgn_out_out(const at::Tensor & self, at::Tensor & out) { structured_sgn_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sgn_meta_inplace final : public at::meta::structured_sgn { structured_sgn_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sgn::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sgn_(at::Tensor & self) { structured_sgn_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sgn", TORCH_FN(wrapper_Meta_sgn)); m.impl("sgn.out", TORCH_FN(wrapper_Meta_sgn_out_out)); m.impl("sgn_", TORCH_FN(wrapper_Meta_sgn_)); } } // anonymous namespace namespace meta { at::Tensor sgn(const at::Tensor & self) { return wrapper_Meta_sgn(self); } at::Tensor & sgn_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sgn_out_out(self, out); } at::Tensor & sgn_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sgn_out_out(self, out); } at::Tensor & sgn_(at::Tensor & self) { return wrapper_Meta_sgn_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_acos_meta_functional final : public at::meta::structured_acos { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_acos(const at::Tensor & self) { structured_acos_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_acos_meta_out final : public at::meta::structured_acos { structured_acos_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_acos_out_out(const at::Tensor & self, at::Tensor & out) { structured_acos_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_acos_meta_inplace final : public at::meta::structured_acos { structured_acos_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_acos_(at::Tensor & self) { structured_acos_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("acos", TORCH_FN(wrapper_Meta_acos)); m.impl("acos.out", TORCH_FN(wrapper_Meta_acos_out_out)); m.impl("acos_", TORCH_FN(wrapper_Meta_acos_)); } } // anonymous namespace namespace meta { at::Tensor acos(const at::Tensor & self) { return wrapper_Meta_acos(self); } at::Tensor & acos_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_acos_out_out(self, out); } at::Tensor & acos_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_acos_out_out(self, out); } at::Tensor & acos_(at::Tensor & self) { return wrapper_Meta_acos_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_add_Tensor_meta_functional final : public at::meta::structured_add_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_add_Tensor(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { structured_add_Tensor_meta_functional op; op.meta(self, other, alpha); return std::move(op.outputs_[0]); } struct structured_add_Tensor_meta_out final : public at::meta::structured_add_Tensor { structured_add_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_add_out_out(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) { structured_add_Tensor_meta_out op(out); op.meta(self, other, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_add_Tensor_meta_inplace final : public at::meta::structured_add_Tensor { structured_add_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_add_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_add__Tensor(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { structured_add_Tensor_meta_inplace op(self); op.meta(self, other, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("add.Tensor", TORCH_FN(wrapper_Meta_add_Tensor)); m.impl("add.out", TORCH_FN(wrapper_Meta_add_out_out)); m.impl("add_.Tensor", TORCH_FN(wrapper_Meta_add__Tensor)); } } // anonymous namespace namespace meta { at::Tensor add(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_add_Tensor(self, other, alpha); } at::Tensor & add_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_add_out_out(self, other, alpha, out); } at::Tensor & add_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_add_out_out(self, other, alpha, out); } at::Tensor & add_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_add__Tensor(self, other, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor__add_relu_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_add_relu_.Tensor", TORCH_FN(wrapper_Meta_Tensor__add_relu_)); } } // anonymous namespace namespace meta { at::Tensor & _add_relu_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_Tensor__add_relu_(self, other, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Scalar__add_relu_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_add_relu_.Scalar", TORCH_FN(wrapper_Meta_Scalar__add_relu_)); } } // anonymous namespace namespace meta { at::Tensor & _add_relu_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) { return wrapper_Meta_Scalar__add_relu_(self, other, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_addmv_meta_functional final : public at::meta::structured_addmv { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_addmv(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha) { structured_addmv_meta_functional op; op.meta(self, mat, vec, beta, alpha); return std::move(op.outputs_[0]); } struct structured_addmv_meta_out final : public at::meta::structured_addmv { structured_addmv_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addmv_out_out(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { structured_addmv_meta_out op(out); op.meta(self, mat, vec, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_addmv_meta_inplace final : public at::meta::structured_addmv { structured_addmv_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addmv_(at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha) { structured_addmv_meta_inplace op(self); op.meta(self, mat, vec, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("addmv", TORCH_FN(wrapper_Meta_addmv)); m.impl("addmv.out", TORCH_FN(wrapper_Meta_addmv_out_out)); m.impl("addmv_", TORCH_FN(wrapper_Meta_addmv_)); } } // anonymous namespace namespace meta { at::Tensor addmv(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmv(self, mat, vec, beta, alpha); } at::Tensor & addmv_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmv_out_out(self, mat, vec, beta, alpha, out); } at::Tensor & addmv_outf(const at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_addmv_out_out(self, mat, vec, beta, alpha, out); } at::Tensor & addmv_(at::Tensor & self, const at::Tensor & mat, const at::Tensor & vec, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmv_(self, mat, vec, beta, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_all_dim_meta_functional final : public at::meta::structured_all_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_all_dim(const at::Tensor & self, int64_t dim, bool keepdim) { structured_all_dim_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_all_dim_meta_out final : public at::meta::structured_all_dim { structured_all_dim_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_all_out_out(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) { structured_all_dim_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("all.dim", TORCH_FN(wrapper_Meta_all_dim)); m.impl("all.out", TORCH_FN(wrapper_Meta_all_out_out)); } } // anonymous namespace namespace meta { at::Tensor all(const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_all_dim(self, dim, keepdim); } at::Tensor & all_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_all_out_out(self, dim, keepdim, out); } at::Tensor & all_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_all_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_all_dims_meta_functional final : public at::meta::structured_all_dims { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_all_dims(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { structured_all_dims_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_all_dims_meta_out final : public at::meta::structured_all_dims { structured_all_dims_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_all_out_dims_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) { structured_all_dims_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("all.dims", TORCH_FN(wrapper_Meta_all_dims)); m.impl("all.dims_out", TORCH_FN(wrapper_Meta_all_out_dims_out)); } } // anonymous namespace namespace meta { at::Tensor all(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { return wrapper_Meta_all_dims(self, dim, keepdim); } at::Tensor & all_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { return wrapper_Meta_all_out_dims_out(self, dim, keepdim, out); } at::Tensor & all_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_all_out_dims_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_any_dim_meta_functional final : public at::meta::structured_any_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_any_dim(const at::Tensor & self, int64_t dim, bool keepdim) { structured_any_dim_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_any_dim_meta_out final : public at::meta::structured_any_dim { structured_any_dim_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_any_out_out(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) { structured_any_dim_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("any.dim", TORCH_FN(wrapper_Meta_any_dim)); m.impl("any.out", TORCH_FN(wrapper_Meta_any_out_out)); } } // anonymous namespace namespace meta { at::Tensor any(const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_any_dim(self, dim, keepdim); } at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_any_out_out(self, dim, keepdim, out); } at::Tensor & any_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_any_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_any_dims_meta_functional final : public at::meta::structured_any_dims { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_any_dims(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { structured_any_dims_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_any_dims_meta_out final : public at::meta::structured_any_dims { structured_any_dims_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_any_out_dims_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) { structured_any_dims_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("any.dims", TORCH_FN(wrapper_Meta_any_dims)); m.impl("any.dims_out", TORCH_FN(wrapper_Meta_any_out_dims_out)); } } // anonymous namespace namespace meta { at::Tensor any(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { return wrapper_Meta_any_dims(self, dim, keepdim); } at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) { return wrapper_Meta_any_out_dims_out(self, dim, keepdim, out); } at::Tensor & any_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_any_out_dims_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_start_out_arange_out(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::arange_out(start, end, step, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("arange.start_out", TORCH_FN(wrapper_Meta_start_out_arange_out)); } } // anonymous namespace namespace meta { at::Tensor & arange_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step) { return wrapper_Meta_start_out_arange_out(start, end, step, out); } at::Tensor & arange_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) { return wrapper_Meta_start_out_arange_out(start, end, step, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_argmax_meta_functional final : public at::meta::structured_argmax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_argmax(const at::Tensor & self, ::std::optional dim, bool keepdim) { structured_argmax_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_argmax_meta_out final : public at::meta::structured_argmax { structured_argmax_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_argmax_out_out(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & out) { structured_argmax_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("argmax", TORCH_FN(wrapper_Meta_argmax)); m.impl("argmax.out", TORCH_FN(wrapper_Meta_argmax_out_out)); } } // anonymous namespace namespace meta { at::Tensor argmax(const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_argmax(self, dim, keepdim); } at::Tensor & argmax_out(at::Tensor & out, const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_argmax_out_out(self, dim, keepdim, out); } at::Tensor & argmax_outf(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_argmax_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_argmin_meta_functional final : public at::meta::structured_argmin { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_argmin(const at::Tensor & self, ::std::optional dim, bool keepdim) { structured_argmin_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_argmin_meta_out final : public at::meta::structured_argmin { structured_argmin_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_argmin_out_out(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & out) { structured_argmin_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("argmin", TORCH_FN(wrapper_Meta_argmin)); m.impl("argmin.out", TORCH_FN(wrapper_Meta_argmin_out_out)); } } // anonymous namespace namespace meta { at::Tensor argmin(const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_argmin(self, dim, keepdim); } at::Tensor & argmin_out(at::Tensor & out, const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_argmin_out_out(self, dim, keepdim, out); } at::Tensor & argmin_outf(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_argmin_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_acosh_meta_functional final : public at::meta::structured_acosh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_acosh(const at::Tensor & self) { structured_acosh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_acosh_meta_out final : public at::meta::structured_acosh { structured_acosh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_acosh_out_out(const at::Tensor & self, at::Tensor & out) { structured_acosh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_acosh_meta_inplace final : public at::meta::structured_acosh { structured_acosh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_acosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_acosh_(at::Tensor & self) { structured_acosh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("acosh", TORCH_FN(wrapper_Meta_acosh)); m.impl("acosh.out", TORCH_FN(wrapper_Meta_acosh_out_out)); m.impl("acosh_", TORCH_FN(wrapper_Meta_acosh_)); } } // anonymous namespace namespace meta { at::Tensor acosh(const at::Tensor & self) { return wrapper_Meta_acosh(self); } at::Tensor & acosh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_acosh_out_out(self, out); } at::Tensor & acosh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_acosh_out_out(self, out); } at::Tensor & acosh_(at::Tensor & self) { return wrapper_Meta_acosh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_asinh_meta_functional final : public at::meta::structured_asinh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_asinh(const at::Tensor & self) { structured_asinh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_asinh_meta_out final : public at::meta::structured_asinh { structured_asinh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_asinh_out_out(const at::Tensor & self, at::Tensor & out) { structured_asinh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_asinh_meta_inplace final : public at::meta::structured_asinh { structured_asinh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_asinh_(at::Tensor & self) { structured_asinh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("asinh", TORCH_FN(wrapper_Meta_asinh)); m.impl("asinh.out", TORCH_FN(wrapper_Meta_asinh_out_out)); m.impl("asinh_", TORCH_FN(wrapper_Meta_asinh_)); } } // anonymous namespace namespace meta { at::Tensor asinh(const at::Tensor & self) { return wrapper_Meta_asinh(self); } at::Tensor & asinh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_asinh_out_out(self, out); } at::Tensor & asinh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_asinh_out_out(self, out); } at::Tensor & asinh_(at::Tensor & self) { return wrapper_Meta_asinh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_atanh_meta_functional final : public at::meta::structured_atanh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_atanh(const at::Tensor & self) { structured_atanh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_atanh_meta_out final : public at::meta::structured_atanh { structured_atanh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atanh_out_out(const at::Tensor & self, at::Tensor & out) { structured_atanh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_atanh_meta_inplace final : public at::meta::structured_atanh { structured_atanh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atanh_(at::Tensor & self) { structured_atanh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("atanh", TORCH_FN(wrapper_Meta_atanh)); m.impl("atanh.out", TORCH_FN(wrapper_Meta_atanh_out_out)); m.impl("atanh_", TORCH_FN(wrapper_Meta_atanh_)); } } // anonymous namespace namespace meta { at::Tensor atanh(const at::Tensor & self) { return wrapper_Meta_atanh(self); } at::Tensor & atanh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_atanh_out_out(self, out); } at::Tensor & atanh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_atanh_out_out(self, out); } at::Tensor & atanh_(at::Tensor & self) { return wrapper_Meta_atanh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__as_strided(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional storage_offset) { // No device check // DeviceGuard omitted return at::native::as_strided_tensorimpl_meta_symint(self, size, stride, storage_offset); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("as_strided", TORCH_FN(wrapper_Meta__as_strided)); } } // anonymous namespace namespace meta { at::Tensor as_strided(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, ::std::optional storage_offset) { return wrapper_Meta__as_strided(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? ::std::make_optional(c10::SymInt(*storage_offset)) : ::std::nullopt); } at::Tensor as_strided_symint(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional storage_offset) { return wrapper_Meta__as_strided(self, size, stride, storage_offset); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_asin_meta_functional final : public at::meta::structured_asin { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_asin(const at::Tensor & self) { structured_asin_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_asin_meta_out final : public at::meta::structured_asin { structured_asin_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_asin_out_out(const at::Tensor & self, at::Tensor & out) { structured_asin_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_asin_meta_inplace final : public at::meta::structured_asin { structured_asin_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_asin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_asin_(at::Tensor & self) { structured_asin_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("asin", TORCH_FN(wrapper_Meta_asin)); m.impl("asin.out", TORCH_FN(wrapper_Meta_asin_out_out)); m.impl("asin_", TORCH_FN(wrapper_Meta_asin_)); } } // anonymous namespace namespace meta { at::Tensor asin(const at::Tensor & self) { return wrapper_Meta_asin(self); } at::Tensor & asin_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_asin_out_out(self, out); } at::Tensor & asin_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_asin_out_out(self, out); } at::Tensor & asin_(at::Tensor & self) { return wrapper_Meta_asin_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_atan_meta_functional final : public at::meta::structured_atan { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_atan(const at::Tensor & self) { structured_atan_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_atan_meta_out final : public at::meta::structured_atan { structured_atan_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atan_out_out(const at::Tensor & self, at::Tensor & out) { structured_atan_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_atan_meta_inplace final : public at::meta::structured_atan { structured_atan_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atan_(at::Tensor & self) { structured_atan_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("atan", TORCH_FN(wrapper_Meta_atan)); m.impl("atan.out", TORCH_FN(wrapper_Meta_atan_out_out)); m.impl("atan_", TORCH_FN(wrapper_Meta_atan_)); } } // anonymous namespace namespace meta { at::Tensor atan(const at::Tensor & self) { return wrapper_Meta_atan(self); } at::Tensor & atan_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_atan_out_out(self, out); } at::Tensor & atan_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_atan_out_out(self, out); } at::Tensor & atan_(at::Tensor & self) { return wrapper_Meta_atan_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_baddbmm_meta_functional final : public at::meta::structured_baddbmm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_baddbmm(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { structured_baddbmm_meta_functional op; op.meta(self, batch1, batch2, beta, alpha); return std::move(op.outputs_[0]); } struct structured_baddbmm_meta_out final : public at::meta::structured_baddbmm { structured_baddbmm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_baddbmm_out_out(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { structured_baddbmm_meta_out op(out); op.meta(self, batch1, batch2, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_baddbmm_meta_inplace final : public at::meta::structured_baddbmm { structured_baddbmm_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_baddbmm_(at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { structured_baddbmm_meta_inplace op(self); op.meta(self, batch1, batch2, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("baddbmm", TORCH_FN(wrapper_Meta_baddbmm)); m.impl("baddbmm.out", TORCH_FN(wrapper_Meta_baddbmm_out_out)); m.impl("baddbmm_", TORCH_FN(wrapper_Meta_baddbmm_)); } } // anonymous namespace namespace meta { at::Tensor baddbmm(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_baddbmm(self, batch1, batch2, beta, alpha); } at::Tensor & baddbmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_baddbmm_out_out(self, batch1, batch2, beta, alpha, out); } at::Tensor & baddbmm_outf(const at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_baddbmm_out_out(self, batch1, batch2, beta, alpha, out); } at::Tensor & baddbmm_(at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_baddbmm_(self, batch1, batch2, beta, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor_bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bernoulli_.Tensor", TORCH_FN(wrapper_Meta_Tensor_bernoulli_)); } } // anonymous namespace namespace meta { at::Tensor & bernoulli_(at::Tensor & self, const at::Tensor & p, ::std::optional generator) { return wrapper_Meta_Tensor_bernoulli_(self, p, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_float_bernoulli_(at::Tensor & self, double p, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bernoulli_.float", TORCH_FN(wrapper_Meta_float_bernoulli_)); } } // anonymous namespace namespace meta { at::Tensor & bernoulli_(at::Tensor & self, double p, ::std::optional generator) { return wrapper_Meta_float_bernoulli_(self, p, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_not_meta_functional final : public at::meta::structured_bitwise_not { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_not(const at::Tensor & self) { structured_bitwise_not_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_bitwise_not_meta_out final : public at::meta::structured_bitwise_not { structured_bitwise_not_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_not_out_out(const at::Tensor & self, at::Tensor & out) { structured_bitwise_not_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_not_meta_inplace final : public at::meta::structured_bitwise_not { structured_bitwise_not_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_not::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_not_(at::Tensor & self) { structured_bitwise_not_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_not", TORCH_FN(wrapper_Meta_bitwise_not)); m.impl("bitwise_not.out", TORCH_FN(wrapper_Meta_bitwise_not_out_out)); m.impl("bitwise_not_", TORCH_FN(wrapper_Meta_bitwise_not_)); } } // anonymous namespace namespace meta { at::Tensor bitwise_not(const at::Tensor & self) { return wrapper_Meta_bitwise_not(self); } at::Tensor & bitwise_not_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_bitwise_not_out_out(self, out); } at::Tensor & bitwise_not_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_bitwise_not_out_out(self, out); } at::Tensor & bitwise_not_(at::Tensor & self) { return wrapper_Meta_bitwise_not_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_copysign_Tensor_meta_functional final : public at::meta::structured_copysign_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_copysign_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_copysign_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_copysign_Tensor_meta_out final : public at::meta::structured_copysign_Tensor { structured_copysign_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_copysign_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_copysign_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_copysign_Tensor_meta_inplace final : public at::meta::structured_copysign_Tensor { structured_copysign_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_copysign_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_copysign__Tensor(at::Tensor & self, const at::Tensor & other) { structured_copysign_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("copysign.Tensor", TORCH_FN(wrapper_Meta_copysign_Tensor)); m.impl("copysign.out", TORCH_FN(wrapper_Meta_copysign_out_out)); m.impl("copysign_.Tensor", TORCH_FN(wrapper_Meta_copysign__Tensor)); } } // anonymous namespace namespace meta { at::Tensor copysign(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_copysign_Tensor(self, other); } at::Tensor & copysign_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_copysign_out_out(self, other, out); } at::Tensor & copysign_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_copysign_out_out(self, other, out); } at::Tensor & copysign_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_copysign__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bmm_meta_functional final : public at::meta::structured_bmm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bmm(const at::Tensor & self, const at::Tensor & mat2) { structured_bmm_meta_functional op; op.meta(self, mat2); return std::move(op.outputs_[0]); } struct structured_bmm_meta_out final : public at::meta::structured_bmm { structured_bmm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bmm_out_out(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) { structured_bmm_meta_out op(out); op.meta(self, mat2); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bmm", TORCH_FN(wrapper_Meta_bmm)); m.impl("bmm.out", TORCH_FN(wrapper_Meta_bmm_out_out)); } } // anonymous namespace namespace meta { at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2) { return wrapper_Meta_bmm(self, mat2); } at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2) { return wrapper_Meta_bmm_out_out(self, mat2, out); } at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) { return wrapper_Meta_bmm_out_out(self, mat2, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_cat_meta_functional final : public at::meta::structured_cat { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_cat(const at::ITensorListRef & tensors, int64_t dim) { structured_cat_meta_functional op; auto precompute = op.meta(tensors, dim); (void)precompute; return std::move(op.outputs_[0]); } struct structured_cat_meta_out final : public at::meta::structured_cat { structured_cat_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cat_out_out(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out) { structured_cat_meta_out op(out); auto precompute = op.meta(tensors, dim); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cat", TORCH_FN(wrapper_Meta_cat)); m.impl("cat.out", TORCH_FN(wrapper_Meta_cat_out_out)); } } // anonymous namespace namespace meta { at::Tensor cat(const at::ITensorListRef & tensors, int64_t dim) { return wrapper_Meta_cat(tensors, dim); } at::Tensor & cat_out(at::Tensor & out, const at::ITensorListRef & tensors, int64_t dim) { return wrapper_Meta_cat_out_out(tensors, dim, out); } at::Tensor & cat_outf(const at::ITensorListRef & tensors, int64_t dim, at::Tensor & out) { return wrapper_Meta_cat_out_out(tensors, dim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_ceil_meta_functional final : public at::meta::structured_ceil { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_ceil(const at::Tensor & self) { structured_ceil_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_ceil_meta_out final : public at::meta::structured_ceil { structured_ceil_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ceil_out_out(const at::Tensor & self, at::Tensor & out) { structured_ceil_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_ceil_meta_inplace final : public at::meta::structured_ceil { structured_ceil_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ceil::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ceil_(at::Tensor & self) { structured_ceil_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("ceil", TORCH_FN(wrapper_Meta_ceil)); m.impl("ceil.out", TORCH_FN(wrapper_Meta_ceil_out_out)); m.impl("ceil_", TORCH_FN(wrapper_Meta_ceil_)); } } // anonymous namespace namespace meta { at::Tensor ceil(const at::Tensor & self) { return wrapper_Meta_ceil(self); } at::Tensor & ceil_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_ceil_out_out(self, out); } at::Tensor & ceil_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_ceil_out_out(self, out); } at::Tensor & ceil_(at::Tensor & self) { return wrapper_Meta_ceil_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_meta_functional final : public at::meta::structured_clamp { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { structured_clamp_meta_functional op; op.meta(self, (min.has_value() ? at::OptionalScalarRef(&(min.value())) : at::OptionalScalarRef()), (max.has_value() ? at::OptionalScalarRef(&(max.value())) : at::OptionalScalarRef())); return std::move(op.outputs_[0]); } struct structured_clamp_meta_out final : public at::meta::structured_clamp { structured_clamp_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_out_out(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max, at::Tensor & out) { structured_clamp_meta_out op(out); op.meta(self, (min.has_value() ? at::OptionalScalarRef(&(min.value())) : at::OptionalScalarRef()), (max.has_value() ? at::OptionalScalarRef(&(max.value())) : at::OptionalScalarRef())); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_meta_inplace final : public at::meta::structured_clamp { structured_clamp_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_(at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { structured_clamp_meta_inplace op(self); op.meta(self, (min.has_value() ? at::OptionalScalarRef(&(min.value())) : at::OptionalScalarRef()), (max.has_value() ? at::OptionalScalarRef(&(max.value())) : at::OptionalScalarRef())); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp", TORCH_FN(wrapper_Meta_clamp)); m.impl("clamp.out", TORCH_FN(wrapper_Meta_clamp_out_out)); m.impl("clamp_", TORCH_FN(wrapper_Meta_clamp_)); } } // anonymous namespace namespace meta { at::Tensor clamp(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp(self, min, max); } at::Tensor & clamp_out(at::Tensor & out, const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp_out_out(self, min, max, out); } at::Tensor & clamp_outf(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max, at::Tensor & out) { return wrapper_Meta_clamp_out_out(self, min, max, out); } at::Tensor & clamp_(at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp_(self, min, max); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_Tensor_meta_functional final : public at::meta::structured_clamp_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp_Tensor(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { structured_clamp_Tensor_meta_functional op; op.meta(self, ((min.has_value() && (*min).defined()) ? at::OptionalTensorRef(*min) : at::OptionalTensorRef()), ((max.has_value() && (*max).defined()) ? at::OptionalTensorRef(*max) : at::OptionalTensorRef())); return std::move(op.outputs_[0]); } struct structured_clamp_Tensor_meta_out final : public at::meta::structured_clamp_Tensor { structured_clamp_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_out_Tensor_out(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max, at::Tensor & out) { structured_clamp_Tensor_meta_out op(out); op.meta(self, ((min.has_value() && (*min).defined()) ? at::OptionalTensorRef(*min) : at::OptionalTensorRef()), ((max.has_value() && (*max).defined()) ? at::OptionalTensorRef(*max) : at::OptionalTensorRef())); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_Tensor_meta_inplace final : public at::meta::structured_clamp_Tensor { structured_clamp_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp__Tensor(at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { structured_clamp_Tensor_meta_inplace op(self); op.meta(self, ((min.has_value() && (*min).defined()) ? at::OptionalTensorRef(*min) : at::OptionalTensorRef()), ((max.has_value() && (*max).defined()) ? at::OptionalTensorRef(*max) : at::OptionalTensorRef())); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp.Tensor", TORCH_FN(wrapper_Meta_clamp_Tensor)); m.impl("clamp.Tensor_out", TORCH_FN(wrapper_Meta_clamp_out_Tensor_out)); m.impl("clamp_.Tensor", TORCH_FN(wrapper_Meta_clamp__Tensor)); } } // anonymous namespace namespace meta { at::Tensor clamp(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp_Tensor(self, min, max); } at::Tensor & clamp_out(at::Tensor & out, const at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp_out_Tensor_out(self, min, max, out); } at::Tensor & clamp_outf(const at::Tensor & self, const ::std::optional & min, const ::std::optional & max, at::Tensor & out) { return wrapper_Meta_clamp_out_Tensor_out(self, min, max, out); } at::Tensor & clamp_(at::Tensor & self, const ::std::optional & min, const ::std::optional & max) { return wrapper_Meta_clamp__Tensor(self, min, max); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_max_meta_functional final : public at::meta::structured_clamp_max { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp_max(const at::Tensor & self, const at::Scalar & max) { structured_clamp_max_meta_functional op; op.meta(self, max); return std::move(op.outputs_[0]); } struct structured_clamp_max_meta_out final : public at::meta::structured_clamp_max { structured_clamp_max_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_max_out_out(const at::Tensor & self, const at::Scalar & max, at::Tensor & out) { structured_clamp_max_meta_out op(out); op.meta(self, max); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_max_meta_inplace final : public at::meta::structured_clamp_max { structured_clamp_max_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_max_(at::Tensor & self, const at::Scalar & max) { structured_clamp_max_meta_inplace op(self); op.meta(self, max); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp_max", TORCH_FN(wrapper_Meta_clamp_max)); m.impl("clamp_max.out", TORCH_FN(wrapper_Meta_clamp_max_out_out)); m.impl("clamp_max_", TORCH_FN(wrapper_Meta_clamp_max_)); } } // anonymous namespace namespace meta { at::Tensor clamp_max(const at::Tensor & self, const at::Scalar & max) { return wrapper_Meta_clamp_max(self, max); } at::Tensor & clamp_max_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & max) { return wrapper_Meta_clamp_max_out_out(self, max, out); } at::Tensor & clamp_max_outf(const at::Tensor & self, const at::Scalar & max, at::Tensor & out) { return wrapper_Meta_clamp_max_out_out(self, max, out); } at::Tensor & clamp_max_(at::Tensor & self, const at::Scalar & max) { return wrapper_Meta_clamp_max_(self, max); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_max_Tensor_meta_functional final : public at::meta::structured_clamp_max_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp_max_Tensor(const at::Tensor & self, const at::Tensor & max) { structured_clamp_max_Tensor_meta_functional op; op.meta(self, max); return std::move(op.outputs_[0]); } struct structured_clamp_max_Tensor_meta_out final : public at::meta::structured_clamp_max_Tensor { structured_clamp_max_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_max_out_Tensor_out(const at::Tensor & self, const at::Tensor & max, at::Tensor & out) { structured_clamp_max_Tensor_meta_out op(out); op.meta(self, max); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_max_Tensor_meta_inplace final : public at::meta::structured_clamp_max_Tensor { structured_clamp_max_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_max_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_max__Tensor(at::Tensor & self, const at::Tensor & max) { structured_clamp_max_Tensor_meta_inplace op(self); op.meta(self, max); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp_max.Tensor", TORCH_FN(wrapper_Meta_clamp_max_Tensor)); m.impl("clamp_max.Tensor_out", TORCH_FN(wrapper_Meta_clamp_max_out_Tensor_out)); m.impl("clamp_max_.Tensor", TORCH_FN(wrapper_Meta_clamp_max__Tensor)); } } // anonymous namespace namespace meta { at::Tensor clamp_max(const at::Tensor & self, const at::Tensor & max) { return wrapper_Meta_clamp_max_Tensor(self, max); } at::Tensor & clamp_max_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & max) { return wrapper_Meta_clamp_max_out_Tensor_out(self, max, out); } at::Tensor & clamp_max_outf(const at::Tensor & self, const at::Tensor & max, at::Tensor & out) { return wrapper_Meta_clamp_max_out_Tensor_out(self, max, out); } at::Tensor & clamp_max_(at::Tensor & self, const at::Tensor & max) { return wrapper_Meta_clamp_max__Tensor(self, max); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_min_meta_functional final : public at::meta::structured_clamp_min { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp_min(const at::Tensor & self, const at::Scalar & min) { structured_clamp_min_meta_functional op; op.meta(self, min); return std::move(op.outputs_[0]); } struct structured_clamp_min_meta_out final : public at::meta::structured_clamp_min { structured_clamp_min_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_min_out_out(const at::Tensor & self, const at::Scalar & min, at::Tensor & out) { structured_clamp_min_meta_out op(out); op.meta(self, min); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_min_meta_inplace final : public at::meta::structured_clamp_min { structured_clamp_min_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_min_(at::Tensor & self, const at::Scalar & min) { structured_clamp_min_meta_inplace op(self); op.meta(self, min); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp_min", TORCH_FN(wrapper_Meta_clamp_min)); m.impl("clamp_min.out", TORCH_FN(wrapper_Meta_clamp_min_out_out)); m.impl("clamp_min_", TORCH_FN(wrapper_Meta_clamp_min_)); } } // anonymous namespace namespace meta { at::Tensor clamp_min(const at::Tensor & self, const at::Scalar & min) { return wrapper_Meta_clamp_min(self, min); } at::Tensor & clamp_min_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & min) { return wrapper_Meta_clamp_min_out_out(self, min, out); } at::Tensor & clamp_min_outf(const at::Tensor & self, const at::Scalar & min, at::Tensor & out) { return wrapper_Meta_clamp_min_out_out(self, min, out); } at::Tensor & clamp_min_(at::Tensor & self, const at::Scalar & min) { return wrapper_Meta_clamp_min_(self, min); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_clamp_min_Tensor_meta_functional final : public at::meta::structured_clamp_min_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_clamp_min_Tensor(const at::Tensor & self, const at::Tensor & min) { structured_clamp_min_Tensor_meta_functional op; op.meta(self, min); return std::move(op.outputs_[0]); } struct structured_clamp_min_Tensor_meta_out final : public at::meta::structured_clamp_min_Tensor { structured_clamp_min_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_min_out_Tensor_out(const at::Tensor & self, const at::Tensor & min, at::Tensor & out) { structured_clamp_min_Tensor_meta_out op(out); op.meta(self, min); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_clamp_min_Tensor_meta_inplace final : public at::meta::structured_clamp_min_Tensor { structured_clamp_min_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_clamp_min_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_clamp_min__Tensor(at::Tensor & self, const at::Tensor & min) { structured_clamp_min_Tensor_meta_inplace op(self); op.meta(self, min); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("clamp_min.Tensor", TORCH_FN(wrapper_Meta_clamp_min_Tensor)); m.impl("clamp_min.Tensor_out", TORCH_FN(wrapper_Meta_clamp_min_out_Tensor_out)); m.impl("clamp_min_.Tensor", TORCH_FN(wrapper_Meta_clamp_min__Tensor)); } } // anonymous namespace namespace meta { at::Tensor clamp_min(const at::Tensor & self, const at::Tensor & min) { return wrapper_Meta_clamp_min_Tensor(self, min); } at::Tensor & clamp_min_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & min) { return wrapper_Meta_clamp_min_out_Tensor_out(self, min, out); } at::Tensor & clamp_min_outf(const at::Tensor & self, const at::Tensor & min, at::Tensor & out) { return wrapper_Meta_clamp_min_out_Tensor_out(self, min, out); } at::Tensor & clamp_min_(at::Tensor & self, const at::Tensor & min) { return wrapper_Meta_clamp_min__Tensor(self, min); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__copy(const at::Tensor & self, const at::Tensor & src, bool non_blocking) { // No device check // DeviceGuard omitted return at::native::copy_meta(self, src, non_blocking); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("copy", TORCH_FN(wrapper_Meta__copy)); } } // anonymous namespace namespace meta { at::Tensor copy(const at::Tensor & self, const at::Tensor & src, bool non_blocking) { return wrapper_Meta__copy(self, src, non_blocking); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_cos_meta_functional final : public at::meta::structured_cos { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_cos(const at::Tensor & self) { structured_cos_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_cos_meta_out final : public at::meta::structured_cos { structured_cos_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cos_out_out(const at::Tensor & self, at::Tensor & out) { structured_cos_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_cos_meta_inplace final : public at::meta::structured_cos { structured_cos_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cos::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cos_(at::Tensor & self) { structured_cos_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cos", TORCH_FN(wrapper_Meta_cos)); m.impl("cos.out", TORCH_FN(wrapper_Meta_cos_out_out)); m.impl("cos_", TORCH_FN(wrapper_Meta_cos_)); } } // anonymous namespace namespace meta { at::Tensor cos(const at::Tensor & self) { return wrapper_Meta_cos(self); } at::Tensor & cos_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_cos_out_out(self, out); } at::Tensor & cos_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_cos_out_out(self, out); } at::Tensor & cos_(at::Tensor & self) { return wrapper_Meta_cos_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_cosh_meta_functional final : public at::meta::structured_cosh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_cosh(const at::Tensor & self) { structured_cosh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_cosh_meta_out final : public at::meta::structured_cosh { structured_cosh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cosh_out_out(const at::Tensor & self, at::Tensor & out) { structured_cosh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_cosh_meta_inplace final : public at::meta::structured_cosh { structured_cosh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_cosh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cosh_(at::Tensor & self) { structured_cosh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cosh", TORCH_FN(wrapper_Meta_cosh)); m.impl("cosh.out", TORCH_FN(wrapper_Meta_cosh_out_out)); m.impl("cosh_", TORCH_FN(wrapper_Meta_cosh_)); } } // anonymous namespace namespace meta { at::Tensor cosh(const at::Tensor & self) { return wrapper_Meta_cosh(self); } at::Tensor & cosh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_cosh_out_out(self, out); } at::Tensor & cosh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_cosh_out_out(self, out); } at::Tensor & cosh_(at::Tensor & self) { return wrapper_Meta_cosh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_cumprod_meta_functional final : public at::meta::structured_cumprod { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_cumprod(const at::Tensor & self, int64_t dim, ::std::optional dtype) { structured_cumprod_meta_functional op; op.meta(self, dim, dtype); return std::move(op.outputs_[0]); } struct structured_cumprod_meta_out final : public at::meta::structured_cumprod { structured_cumprod_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cumprod_out_out(const at::Tensor & self, int64_t dim, ::std::optional dtype, at::Tensor & out) { structured_cumprod_meta_out op(out); op.meta(self, dim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_cumprod_meta_inplace final : public at::meta::structured_cumprod { structured_cumprod_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cumprod_(at::Tensor & self, int64_t dim, ::std::optional dtype) { structured_cumprod_meta_inplace op(self); op.meta(self, dim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cumprod", TORCH_FN(wrapper_Meta_cumprod)); m.impl("cumprod.out", TORCH_FN(wrapper_Meta_cumprod_out_out)); m.impl("cumprod_", TORCH_FN(wrapper_Meta_cumprod_)); } } // anonymous namespace namespace meta { at::Tensor cumprod(const at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumprod(self, dim, dtype); } at::Tensor & cumprod_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumprod_out_out(self, dim, dtype, out); } at::Tensor & cumprod_outf(const at::Tensor & self, int64_t dim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_cumprod_out_out(self, dim, dtype, out); } at::Tensor & cumprod_(at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumprod_(self, dim, dtype); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_cumsum_meta_functional final : public at::meta::structured_cumsum { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_cumsum(const at::Tensor & self, int64_t dim, ::std::optional dtype) { structured_cumsum_meta_functional op; op.meta(self, dim, dtype); return std::move(op.outputs_[0]); } struct structured_cumsum_meta_out final : public at::meta::structured_cumsum { structured_cumsum_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cumsum_out_out(const at::Tensor & self, int64_t dim, ::std::optional dtype, at::Tensor & out) { structured_cumsum_meta_out op(out); op.meta(self, dim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_cumsum_meta_inplace final : public at::meta::structured_cumsum { structured_cumsum_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_cumsum_(at::Tensor & self, int64_t dim, ::std::optional dtype) { structured_cumsum_meta_inplace op(self); op.meta(self, dim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cumsum", TORCH_FN(wrapper_Meta_cumsum)); m.impl("cumsum.out", TORCH_FN(wrapper_Meta_cumsum_out_out)); m.impl("cumsum_", TORCH_FN(wrapper_Meta_cumsum_)); } } // anonymous namespace namespace meta { at::Tensor cumsum(const at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumsum(self, dim, dtype); } at::Tensor & cumsum_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumsum_out_out(self, dim, dtype, out); } at::Tensor & cumsum_outf(const at::Tensor & self, int64_t dim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_cumsum_out_out(self, dim, dtype, out); } at::Tensor & cumsum_(at::Tensor & self, int64_t dim, ::std::optional dtype) { return wrapper_Meta_cumsum_(self, dim, dtype); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { ::std::tuple wrapper_Meta___ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity) { // No device check // DeviceGuard omitted return at::native::ctc_loss_meta(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_ctc_loss", TORCH_FN(wrapper_Meta___ctc_loss)); } } // anonymous namespace namespace meta { ::std::tuple _ctc_loss(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity) { return wrapper_Meta___ctc_loss(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_div_Tensor_meta_functional final : public at::meta::structured_div_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_div_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_div_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_div_Tensor_meta_out final : public at::meta::structured_div_Tensor { structured_div_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_div_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_div_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_div_Tensor_meta_inplace final : public at::meta::structured_div_Tensor { structured_div_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_div__Tensor(at::Tensor & self, const at::Tensor & other) { structured_div_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("div.Tensor", TORCH_FN(wrapper_Meta_div_Tensor)); m.impl("div.out", TORCH_FN(wrapper_Meta_div_out_out)); m.impl("div_.Tensor", TORCH_FN(wrapper_Meta_div__Tensor)); } } // anonymous namespace namespace meta { at::Tensor div(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_div_Tensor(self, other); } at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_div_out_out(self, other, out); } at::Tensor & div_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_div_out_out(self, other, out); } at::Tensor & div_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_div__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_div_Tensor_mode_meta_functional final : public at::meta::structured_div_Tensor_mode { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_div_Tensor_mode(const at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode) { structured_div_Tensor_mode_meta_functional op; op.meta(self, other, rounding_mode); return std::move(op.outputs_[0]); } struct structured_div_Tensor_mode_meta_out final : public at::meta::structured_div_Tensor_mode { structured_div_Tensor_mode_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_div_out_out_mode(const at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode, at::Tensor & out) { structured_div_Tensor_mode_meta_out op(out); op.meta(self, other, rounding_mode); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_div_Tensor_mode_meta_inplace final : public at::meta::structured_div_Tensor_mode { structured_div_Tensor_mode_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_div_Tensor_mode::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_div__Tensor_mode(at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode) { structured_div_Tensor_mode_meta_inplace op(self); op.meta(self, other, rounding_mode); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("div.Tensor_mode", TORCH_FN(wrapper_Meta_div_Tensor_mode)); m.impl("div.out_mode", TORCH_FN(wrapper_Meta_div_out_out_mode)); m.impl("div_.Tensor_mode", TORCH_FN(wrapper_Meta_div__Tensor_mode)); } } // anonymous namespace namespace meta { at::Tensor div(const at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode) { return wrapper_Meta_div_Tensor_mode(self, other, rounding_mode); } at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode) { return wrapper_Meta_div_out_out_mode(self, other, rounding_mode, out); } at::Tensor & div_outf(const at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode, at::Tensor & out) { return wrapper_Meta_div_out_out_mode(self, other, rounding_mode, out); } at::Tensor & div_(at::Tensor & self, const at::Tensor & other, ::std::optional rounding_mode) { return wrapper_Meta_div__Tensor_mode(self, other, rounding_mode); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__embedding_renorm_(at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("embedding_renorm_", TORCH_FN(wrapper_Meta__embedding_renorm_)); } } // anonymous namespace namespace meta { at::Tensor & embedding_renorm_(at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) { return wrapper_Meta__embedding_renorm_(self, indices, max_norm, norm_type); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta_memory_format_empty(c10::SymIntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional memory_format) { // No device check // DeviceGuard omitted return at::native::empty_meta_symint(size, dtype, layout, device, pin_memory, memory_format); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("empty.memory_format", TORCH_FN(wrapper_Meta_memory_format_empty)); } } // anonymous namespace namespace meta { at::Tensor empty(at::IntArrayRef size, at::TensorOptions options, ::std::optional memory_format) { return wrapper_Meta_memory_format_empty(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format)); } at::Tensor empty(at::IntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional memory_format) { return wrapper_Meta_memory_format_empty(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory, memory_format); } at::Tensor empty_symint(c10::SymIntArrayRef size, at::TensorOptions options, ::std::optional memory_format) { return wrapper_Meta_memory_format_empty(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format)); } at::Tensor empty_symint(c10::SymIntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional memory_format) { return wrapper_Meta_memory_format_empty(size, dtype, layout, device, pin_memory, memory_format); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { const at::Tensor & wrapper_Meta__resize_(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional memory_format) { // No device check // DeviceGuard omitted return at::native::resize__symint(self, size, memory_format); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("resize_", TORCH_FN(wrapper_Meta__resize_)); } } // anonymous namespace namespace meta { const at::Tensor & resize_(const at::Tensor & self, at::IntArrayRef size, ::std::optional memory_format) { return wrapper_Meta__resize_(self, c10::fromIntArrayRefSlow(size), memory_format); } const at::Tensor & resize__symint(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional memory_format) { return wrapper_Meta__resize_(self, size, memory_format); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { const at::Tensor & wrapper_Meta___resize_output_(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device) { // No device check // DeviceGuard omitted return at::native::_resize_output_(self, C10_AS_INTARRAYREF_SLOW(size), device); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_resize_output_", TORCH_FN(wrapper_Meta___resize_output_)); } } // anonymous namespace namespace meta { const at::Tensor & _resize_output_(const at::Tensor & self, at::IntArrayRef size, at::Device device) { return wrapper_Meta___resize_output_(self, c10::fromIntArrayRefSlow(size), device); } const at::Tensor & _resize_output__symint(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device) { return wrapper_Meta___resize_output_(self, size, device); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__empty_strided(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { // No device check // DeviceGuard omitted return at::native::empty_strided_meta_symint(size, stride, dtype, layout, device, pin_memory); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("empty_strided", TORCH_FN(wrapper_Meta__empty_strided)); } } // anonymous namespace namespace meta { at::Tensor empty_strided(at::IntArrayRef size, at::IntArrayRef stride, at::TensorOptions options) { return wrapper_Meta__empty_strided(c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); } at::Tensor empty_strided(at::IntArrayRef size, at::IntArrayRef stride, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { return wrapper_Meta__empty_strided(c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), dtype, layout, device, pin_memory); } at::Tensor empty_strided_symint(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::TensorOptions options) { return wrapper_Meta__empty_strided(size, stride, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); } at::Tensor empty_strided_symint(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { return wrapper_Meta__empty_strided(size, stride, dtype, layout, device, pin_memory); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_erf_meta_functional final : public at::meta::structured_erf { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_erf(const at::Tensor & self) { structured_erf_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_erf_meta_out final : public at::meta::structured_erf { structured_erf_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erf_out_out(const at::Tensor & self, at::Tensor & out) { structured_erf_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_erf_meta_inplace final : public at::meta::structured_erf { structured_erf_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erf_(at::Tensor & self) { structured_erf_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("erf", TORCH_FN(wrapper_Meta_erf)); m.impl("erf.out", TORCH_FN(wrapper_Meta_erf_out_out)); m.impl("erf_", TORCH_FN(wrapper_Meta_erf_)); } } // anonymous namespace namespace meta { at::Tensor erf(const at::Tensor & self) { return wrapper_Meta_erf(self); } at::Tensor & erf_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_erf_out_out(self, out); } at::Tensor & erf_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_erf_out_out(self, out); } at::Tensor & erf_(at::Tensor & self) { return wrapper_Meta_erf_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_erfc_meta_functional final : public at::meta::structured_erfc { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_erfc(const at::Tensor & self) { structured_erfc_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_erfc_meta_out final : public at::meta::structured_erfc { structured_erfc_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erfc_out_out(const at::Tensor & self, at::Tensor & out) { structured_erfc_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_erfc_meta_inplace final : public at::meta::structured_erfc { structured_erfc_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erfc_(at::Tensor & self) { structured_erfc_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("erfc", TORCH_FN(wrapper_Meta_erfc)); m.impl("erfc.out", TORCH_FN(wrapper_Meta_erfc_out_out)); m.impl("erfc_", TORCH_FN(wrapper_Meta_erfc_)); } } // anonymous namespace namespace meta { at::Tensor erfc(const at::Tensor & self) { return wrapper_Meta_erfc(self); } at::Tensor & erfc_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_erfc_out_out(self, out); } at::Tensor & erfc_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_erfc_out_out(self, out); } at::Tensor & erfc_(at::Tensor & self) { return wrapper_Meta_erfc_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_exp_meta_functional final : public at::meta::structured_exp { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_exp(const at::Tensor & self) { structured_exp_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_exp_meta_out final : public at::meta::structured_exp { structured_exp_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_exp_out_out(const at::Tensor & self, at::Tensor & out) { structured_exp_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_exp_meta_inplace final : public at::meta::structured_exp { structured_exp_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_exp_(at::Tensor & self) { structured_exp_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("exp", TORCH_FN(wrapper_Meta_exp)); m.impl("exp.out", TORCH_FN(wrapper_Meta_exp_out_out)); m.impl("exp_", TORCH_FN(wrapper_Meta_exp_)); } } // anonymous namespace namespace meta { at::Tensor exp(const at::Tensor & self) { return wrapper_Meta_exp(self); } at::Tensor & exp_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_exp_out_out(self, out); } at::Tensor & exp_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_exp_out_out(self, out); } at::Tensor & exp_(at::Tensor & self) { return wrapper_Meta_exp_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_exp2_meta_functional final : public at::meta::structured_exp2 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_exp2(const at::Tensor & self) { structured_exp2_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_exp2_meta_out final : public at::meta::structured_exp2 { structured_exp2_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_exp2_out_out(const at::Tensor & self, at::Tensor & out) { structured_exp2_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_exp2_meta_inplace final : public at::meta::structured_exp2 { structured_exp2_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_exp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_exp2_(at::Tensor & self) { structured_exp2_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("exp2", TORCH_FN(wrapper_Meta_exp2)); m.impl("exp2.out", TORCH_FN(wrapper_Meta_exp2_out_out)); m.impl("exp2_", TORCH_FN(wrapper_Meta_exp2_)); } } // anonymous namespace namespace meta { at::Tensor exp2(const at::Tensor & self) { return wrapper_Meta_exp2(self); } at::Tensor & exp2_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_exp2_out_out(self, out); } at::Tensor & exp2_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_exp2_out_out(self, out); } at::Tensor & exp2_(at::Tensor & self) { return wrapper_Meta_exp2_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_expm1_meta_functional final : public at::meta::structured_expm1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_expm1(const at::Tensor & self) { structured_expm1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_expm1_meta_out final : public at::meta::structured_expm1 { structured_expm1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_expm1_out_out(const at::Tensor & self, at::Tensor & out) { structured_expm1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_expm1_meta_inplace final : public at::meta::structured_expm1 { structured_expm1_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_expm1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_expm1_(at::Tensor & self) { structured_expm1_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("expm1", TORCH_FN(wrapper_Meta_expm1)); m.impl("expm1.out", TORCH_FN(wrapper_Meta_expm1_out_out)); m.impl("expm1_", TORCH_FN(wrapper_Meta_expm1_)); } } // anonymous namespace namespace meta { at::Tensor expm1(const at::Tensor & self) { return wrapper_Meta_expm1(self); } at::Tensor & expm1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_expm1_out_out(self, out); } at::Tensor & expm1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_expm1_out_out(self, out); } at::Tensor & expm1_(at::Tensor & self) { return wrapper_Meta_expm1_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_out_eye_out(c10::SymInt n, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::eye_out_cpu(n.guard_int(__FILE__, __LINE__), out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("eye.out", TORCH_FN(wrapper_Meta_out_eye_out)); } } // anonymous namespace namespace meta { at::Tensor & eye_out(at::Tensor & out, int64_t n) { return wrapper_Meta_out_eye_out(n, out); } at::Tensor & eye_outf(int64_t n, at::Tensor & out) { return wrapper_Meta_out_eye_out(n, out); } at::Tensor & eye_symint_out(at::Tensor & out, c10::SymInt n) { return wrapper_Meta_out_eye_out(n, out); } at::Tensor & eye_symint_outf(c10::SymInt n, at::Tensor & out) { return wrapper_Meta_out_eye_out(n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_m_out_eye_out(c10::SymInt n, c10::SymInt m, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::eye_out_cpu(n.guard_int(__FILE__, __LINE__), m.guard_int(__FILE__, __LINE__), out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("eye.m_out", TORCH_FN(wrapper_Meta_m_out_eye_out)); } } // anonymous namespace namespace meta { at::Tensor & eye_out(at::Tensor & out, int64_t n, int64_t m) { return wrapper_Meta_m_out_eye_out(n, m, out); } at::Tensor & eye_outf(int64_t n, int64_t m, at::Tensor & out) { return wrapper_Meta_m_out_eye_out(n, m, out); } at::Tensor & eye_symint_out(at::Tensor & out, c10::SymInt n, c10::SymInt m) { return wrapper_Meta_m_out_eye_out(n, m, out); } at::Tensor & eye_symint_outf(c10::SymInt n, c10::SymInt m, at::Tensor & out) { return wrapper_Meta_m_out_eye_out(n, m, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_Scalar_fill_(at::Tensor & self, const at::Scalar & value) { // No device check // DeviceGuard omitted return at::native::fill_meta_(self, value); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fill_.Scalar", TORCH_FN(wrapper_Meta_Scalar_fill_)); } } // anonymous namespace namespace meta { at::Tensor & fill_(at::Tensor & self, const at::Scalar & value) { return wrapper_Meta_Scalar_fill_(self, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_Tensor_fill_(at::Tensor & self, const at::Tensor & value) { // No device check // DeviceGuard omitted return at::native::fill_meta_(self, value); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fill_.Tensor", TORCH_FN(wrapper_Meta_Tensor_fill_)); } } // anonymous namespace namespace meta { at::Tensor & fill_(at::Tensor & self, const at::Tensor & value) { return wrapper_Meta_Tensor_fill_(self, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_floor_meta_functional final : public at::meta::structured_floor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_floor(const at::Tensor & self) { structured_floor_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_floor_meta_out final : public at::meta::structured_floor { structured_floor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_floor_out_out(const at::Tensor & self, at::Tensor & out) { structured_floor_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_floor_meta_inplace final : public at::meta::structured_floor { structured_floor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_floor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_floor_(at::Tensor & self) { structured_floor_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("floor", TORCH_FN(wrapper_Meta_floor)); m.impl("floor.out", TORCH_FN(wrapper_Meta_floor_out_out)); m.impl("floor_", TORCH_FN(wrapper_Meta_floor_)); } } // anonymous namespace namespace meta { at::Tensor floor(const at::Tensor & self) { return wrapper_Meta_floor(self); } at::Tensor & floor_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_floor_out_out(self, out); } at::Tensor & floor_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_floor_out_out(self, out); } at::Tensor & floor_(at::Tensor & self) { return wrapper_Meta_floor_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor_floor_divide_(at::Tensor & self, const at::Tensor & other) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("floor_divide_.Tensor", TORCH_FN(wrapper_Meta_Tensor_floor_divide_)); } } // anonymous namespace namespace meta { at::Tensor & floor_divide_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_Tensor_floor_divide_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_frac_meta_functional final : public at::meta::structured_frac { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_frac(const at::Tensor & self) { structured_frac_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_frac_meta_out final : public at::meta::structured_frac { structured_frac_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_frac_out_out(const at::Tensor & self, at::Tensor & out) { structured_frac_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_frac_meta_inplace final : public at::meta::structured_frac { structured_frac_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_frac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_frac_(at::Tensor & self) { structured_frac_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("frac", TORCH_FN(wrapper_Meta_frac)); m.impl("frac.out", TORCH_FN(wrapper_Meta_frac_out_out)); m.impl("frac_", TORCH_FN(wrapper_Meta_frac_)); } } // anonymous namespace namespace meta { at::Tensor frac(const at::Tensor & self) { return wrapper_Meta_frac(self); } at::Tensor & frac_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_frac_out_out(self, out); } at::Tensor & frac_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_frac_out_out(self, out); } at::Tensor & frac_(at::Tensor & self) { return wrapper_Meta_frac_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gcd_meta_functional final : public at::meta::structured_gcd { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gcd(const at::Tensor & self, const at::Tensor & other) { structured_gcd_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_gcd_meta_out final : public at::meta::structured_gcd { structured_gcd_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gcd_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_gcd_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_gcd_meta_inplace final : public at::meta::structured_gcd { structured_gcd_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gcd::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gcd_(at::Tensor & self, const at::Tensor & other) { structured_gcd_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gcd", TORCH_FN(wrapper_Meta_gcd)); m.impl("gcd.out", TORCH_FN(wrapper_Meta_gcd_out_out)); m.impl("gcd_", TORCH_FN(wrapper_Meta_gcd_)); } } // anonymous namespace namespace meta { at::Tensor gcd(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gcd(self, other); } at::Tensor & gcd_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gcd_out_out(self, other, out); } at::Tensor & gcd_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_gcd_out_out(self, other, out); } at::Tensor & gcd_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gcd_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lcm_meta_functional final : public at::meta::structured_lcm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lcm(const at::Tensor & self, const at::Tensor & other) { structured_lcm_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_lcm_meta_out final : public at::meta::structured_lcm { structured_lcm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lcm_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_lcm_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lcm_meta_inplace final : public at::meta::structured_lcm { structured_lcm_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lcm::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lcm_(at::Tensor & self, const at::Tensor & other) { structured_lcm_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lcm", TORCH_FN(wrapper_Meta_lcm)); m.impl("lcm.out", TORCH_FN(wrapper_Meta_lcm_out_out)); m.impl("lcm_", TORCH_FN(wrapper_Meta_lcm_)); } } // anonymous namespace namespace meta { at::Tensor lcm(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lcm(self, other); } at::Tensor & lcm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lcm_out_out(self, other, out); } at::Tensor & lcm_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_lcm_out_out(self, other, out); } at::Tensor & lcm_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lcm_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_index_Tensor_meta_functional final : public at::meta::structured_index_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_index_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_index_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_index_Tensor(const at::Tensor & self, const c10::List<::std::optional> & indices) { structured_index_Tensor_meta_functional op; auto precompute = op.meta(self, at::IOptTensorListRef(indices)); (void)precompute; return std::move(op.outputs_[0]); } struct structured_index_Tensor_meta_out final : public at::meta::structured_index_Tensor { structured_index_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_index_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_index_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_out_Tensor_out(const at::Tensor & self, const c10::List<::std::optional> & indices, at::Tensor & out) { structured_index_Tensor_meta_out op(out); auto precompute = op.meta(self, at::IOptTensorListRef(indices)); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index.Tensor", TORCH_FN(wrapper_Meta_index_Tensor)); m.impl("index.Tensor_out", TORCH_FN(wrapper_Meta_index_out_Tensor_out)); } } // anonymous namespace namespace meta { at::Tensor index(const at::Tensor & self, const c10::List<::std::optional> & indices) { return wrapper_Meta_index_Tensor(self, indices); } at::Tensor & index_out(at::Tensor & out, const at::Tensor & self, const c10::List<::std::optional> & indices) { return wrapper_Meta_index_out_Tensor_out(self, indices, out); } at::Tensor & index_outf(const at::Tensor & self, const c10::List<::std::optional> & indices, at::Tensor & out) { return wrapper_Meta_index_out_Tensor_out(self, indices, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_index_copy_meta_functional final : public at::meta::structured_index_copy { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_index_copy(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source) { structured_index_copy_meta_functional op; auto precompute = op.meta(self, dim, index, source); (void)precompute; return std::move(op.outputs_[0]); } struct structured_index_copy_meta_out final : public at::meta::structured_index_copy { structured_index_copy_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_copy_out_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, at::Tensor & out) { structured_index_copy_meta_out op(out); auto precompute = op.meta(self, dim, index, source); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_index_copy_meta_inplace final : public at::meta::structured_index_copy { structured_index_copy_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_copy_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source) { structured_index_copy_meta_inplace op(self); auto precompute = op.meta(self, dim, index, source); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index_copy", TORCH_FN(wrapper_Meta_index_copy)); m.impl("index_copy.out", TORCH_FN(wrapper_Meta_index_copy_out_out)); m.impl("index_copy_", TORCH_FN(wrapper_Meta_index_copy_)); } } // anonymous namespace namespace meta { at::Tensor index_copy(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source) { return wrapper_Meta_index_copy(self, dim, index, source); } at::Tensor & index_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source) { return wrapper_Meta_index_copy_out_out(self, dim, index, source, out); } at::Tensor & index_copy_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, at::Tensor & out) { return wrapper_Meta_index_copy_out_out(self, dim, index, source, out); } at::Tensor & index_copy_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source) { return wrapper_Meta_index_copy_(self, dim, index, source); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta___index_put_impl_(at::Tensor & self, const c10::List<::std::optional> & indices, const at::Tensor & values, bool accumulate, bool unsafe) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_index_put_impl_", TORCH_FN(wrapper_Meta___index_put_impl_)); } } // anonymous namespace namespace meta { at::Tensor & _index_put_impl_(at::Tensor & self, const c10::List<::std::optional> & indices, const at::Tensor & values, bool accumulate, bool unsafe) { return wrapper_Meta___index_put_impl_(self, indices, values, accumulate, unsafe); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_isin_Tensor_Tensor_meta_functional final : public at::meta::structured_isin_Tensor_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_isin_Tensor_Tensor(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert) { structured_isin_Tensor_Tensor_meta_functional op; op.meta(elements, test_elements, assume_unique, invert); return std::move(op.outputs_[0]); } struct structured_isin_Tensor_Tensor_meta_out final : public at::meta::structured_isin_Tensor_Tensor { structured_isin_Tensor_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_isin_out_Tensor_Tensor_out(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { structured_isin_Tensor_Tensor_meta_out op(out); op.meta(elements, test_elements, assume_unique, invert); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("isin.Tensor_Tensor", TORCH_FN(wrapper_Meta_isin_Tensor_Tensor)); m.impl("isin.Tensor_Tensor_out", TORCH_FN(wrapper_Meta_isin_out_Tensor_Tensor_out)); } } // anonymous namespace namespace meta { at::Tensor isin(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert) { return wrapper_Meta_isin_Tensor_Tensor(elements, test_elements, assume_unique, invert); } at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert) { return wrapper_Meta_isin_out_Tensor_Tensor_out(elements, test_elements, assume_unique, invert, out); } at::Tensor & isin_outf(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { return wrapper_Meta_isin_out_Tensor_Tensor_out(elements, test_elements, assume_unique, invert, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_isin_Tensor_Scalar_meta_functional final : public at::meta::structured_isin_Tensor_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_isin_Tensor_Scalar(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert) { structured_isin_Tensor_Scalar_meta_functional op; op.meta(elements, test_element, assume_unique, invert); return std::move(op.outputs_[0]); } struct structured_isin_Tensor_Scalar_meta_out final : public at::meta::structured_isin_Tensor_Scalar { structured_isin_Tensor_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_isin_out_Tensor_Scalar_out(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out) { structured_isin_Tensor_Scalar_meta_out op(out); op.meta(elements, test_element, assume_unique, invert); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("isin.Tensor_Scalar", TORCH_FN(wrapper_Meta_isin_Tensor_Scalar)); m.impl("isin.Tensor_Scalar_out", TORCH_FN(wrapper_Meta_isin_out_Tensor_Scalar_out)); } } // anonymous namespace namespace meta { at::Tensor isin(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert) { return wrapper_Meta_isin_Tensor_Scalar(elements, test_element, assume_unique, invert); } at::Tensor & isin_out(at::Tensor & out, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert) { return wrapper_Meta_isin_out_Tensor_Scalar_out(elements, test_element, assume_unique, invert, out); } at::Tensor & isin_outf(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out) { return wrapper_Meta_isin_out_Tensor_Scalar_out(elements, test_element, assume_unique, invert, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_isin_Scalar_Tensor_meta_functional final : public at::meta::structured_isin_Scalar_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_isin_Scalar_Tensor(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert) { structured_isin_Scalar_Tensor_meta_functional op; op.meta(element, test_elements, assume_unique, invert); return std::move(op.outputs_[0]); } struct structured_isin_Scalar_Tensor_meta_out final : public at::meta::structured_isin_Scalar_Tensor { structured_isin_Scalar_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_isin_out_Scalar_Tensor_out(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { structured_isin_Scalar_Tensor_meta_out op(out); op.meta(element, test_elements, assume_unique, invert); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("isin.Scalar_Tensor", TORCH_FN(wrapper_Meta_isin_Scalar_Tensor)); m.impl("isin.Scalar_Tensor_out", TORCH_FN(wrapper_Meta_isin_out_Scalar_Tensor_out)); } } // anonymous namespace namespace meta { at::Tensor isin(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert) { return wrapper_Meta_isin_Scalar_Tensor(element, test_elements, assume_unique, invert); } at::Tensor & isin_out(at::Tensor & out, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert) { return wrapper_Meta_isin_out_Scalar_Tensor_out(element, test_elements, assume_unique, invert, out); } at::Tensor & isin_outf(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out) { return wrapper_Meta_isin_out_Scalar_Tensor_out(element, test_elements, assume_unique, invert, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_out_linspace_out(const at::Scalar & start, const at::Scalar & end, int64_t steps, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::linspace_out(start, end, steps, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linspace.out", TORCH_FN(wrapper_Meta_out_linspace_out)); } } // anonymous namespace namespace meta { at::Tensor & linspace_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, int64_t steps) { return wrapper_Meta_out_linspace_out(start, end, steps, out); } at::Tensor & linspace_outf(const at::Scalar & start, const at::Scalar & end, int64_t steps, at::Tensor & out) { return wrapper_Meta_out_linspace_out(start, end, steps, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_log_meta_functional final : public at::meta::structured_log { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_log(const at::Tensor & self) { structured_log_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_log_meta_out final : public at::meta::structured_log { structured_log_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log_out_out(const at::Tensor & self, at::Tensor & out) { structured_log_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_log_meta_inplace final : public at::meta::structured_log { structured_log_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log_(at::Tensor & self) { structured_log_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("log", TORCH_FN(wrapper_Meta_log)); m.impl("log.out", TORCH_FN(wrapper_Meta_log_out_out)); m.impl("log_", TORCH_FN(wrapper_Meta_log_)); } } // anonymous namespace namespace meta { at::Tensor log(const at::Tensor & self) { return wrapper_Meta_log(self); } at::Tensor & log_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_log_out_out(self, out); } at::Tensor & log_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_log_out_out(self, out); } at::Tensor & log_(at::Tensor & self) { return wrapper_Meta_log_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_log10_meta_functional final : public at::meta::structured_log10 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_log10(const at::Tensor & self) { structured_log10_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_log10_meta_out final : public at::meta::structured_log10 { structured_log10_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log10_out_out(const at::Tensor & self, at::Tensor & out) { structured_log10_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_log10_meta_inplace final : public at::meta::structured_log10 { structured_log10_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log10::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log10_(at::Tensor & self) { structured_log10_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("log10", TORCH_FN(wrapper_Meta_log10)); m.impl("log10.out", TORCH_FN(wrapper_Meta_log10_out_out)); m.impl("log10_", TORCH_FN(wrapper_Meta_log10_)); } } // anonymous namespace namespace meta { at::Tensor log10(const at::Tensor & self) { return wrapper_Meta_log10(self); } at::Tensor & log10_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_log10_out_out(self, out); } at::Tensor & log10_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_log10_out_out(self, out); } at::Tensor & log10_(at::Tensor & self) { return wrapper_Meta_log10_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_log1p_meta_functional final : public at::meta::structured_log1p { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_log1p(const at::Tensor & self) { structured_log1p_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_log1p_meta_out final : public at::meta::structured_log1p { structured_log1p_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log1p_out_out(const at::Tensor & self, at::Tensor & out) { structured_log1p_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_log1p_meta_inplace final : public at::meta::structured_log1p { structured_log1p_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log1p::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log1p_(at::Tensor & self) { structured_log1p_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("log1p", TORCH_FN(wrapper_Meta_log1p)); m.impl("log1p.out", TORCH_FN(wrapper_Meta_log1p_out_out)); m.impl("log1p_", TORCH_FN(wrapper_Meta_log1p_)); } } // anonymous namespace namespace meta { at::Tensor log1p(const at::Tensor & self) { return wrapper_Meta_log1p(self); } at::Tensor & log1p_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_log1p_out_out(self, out); } at::Tensor & log1p_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_log1p_out_out(self, out); } at::Tensor & log1p_(at::Tensor & self) { return wrapper_Meta_log1p_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_log2_meta_functional final : public at::meta::structured_log2 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_log2(const at::Tensor & self) { structured_log2_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_log2_meta_out final : public at::meta::structured_log2 { structured_log2_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log2_out_out(const at::Tensor & self, at::Tensor & out) { structured_log2_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_log2_meta_inplace final : public at::meta::structured_log2 { structured_log2_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_log2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_log2_(at::Tensor & self) { structured_log2_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("log2", TORCH_FN(wrapper_Meta_log2)); m.impl("log2.out", TORCH_FN(wrapper_Meta_log2_out_out)); m.impl("log2_", TORCH_FN(wrapper_Meta_log2_)); } } // anonymous namespace namespace meta { at::Tensor log2(const at::Tensor & self) { return wrapper_Meta_log2(self); } at::Tensor & log2_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_log2_out_out(self, out); } at::Tensor & log2_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_log2_out_out(self, out); } at::Tensor & log2_(at::Tensor & self) { return wrapper_Meta_log2_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_logaddexp_meta_functional final : public at::meta::structured_logaddexp { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_logaddexp(const at::Tensor & self, const at::Tensor & other) { structured_logaddexp_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_logaddexp_meta_out final : public at::meta::structured_logaddexp { structured_logaddexp_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_logaddexp_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_logaddexp_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("logaddexp", TORCH_FN(wrapper_Meta_logaddexp)); m.impl("logaddexp.out", TORCH_FN(wrapper_Meta_logaddexp_out_out)); } } // anonymous namespace namespace meta { at::Tensor logaddexp(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_logaddexp(self, other); } at::Tensor & logaddexp_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_logaddexp_out_out(self, other, out); } at::Tensor & logaddexp_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_logaddexp_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_logaddexp2_meta_functional final : public at::meta::structured_logaddexp2 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_logaddexp2(const at::Tensor & self, const at::Tensor & other) { structured_logaddexp2_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_logaddexp2_meta_out final : public at::meta::structured_logaddexp2 { structured_logaddexp2_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logaddexp2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_logaddexp2_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_logaddexp2_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("logaddexp2", TORCH_FN(wrapper_Meta_logaddexp2)); m.impl("logaddexp2.out", TORCH_FN(wrapper_Meta_logaddexp2_out_out)); } } // anonymous namespace namespace meta { at::Tensor logaddexp2(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_logaddexp2(self, other); } at::Tensor & logaddexp2_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_logaddexp2_out_out(self, other, out); } at::Tensor & logaddexp2_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_logaddexp2_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_xlogy_Tensor_meta_functional final : public at::meta::structured_xlogy_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_xlogy_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_xlogy_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_xlogy_Tensor_meta_out final : public at::meta::structured_xlogy_Tensor { structured_xlogy_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_xlogy_out_OutTensor(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_xlogy_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_xlogy_Tensor_meta_inplace final : public at::meta::structured_xlogy_Tensor { structured_xlogy_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_xlogy_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_xlogy__Tensor(at::Tensor & self, const at::Tensor & other) { structured_xlogy_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("xlogy.Tensor", TORCH_FN(wrapper_Meta_xlogy_Tensor)); m.impl("xlogy.OutTensor", TORCH_FN(wrapper_Meta_xlogy_out_OutTensor)); m.impl("xlogy_.Tensor", TORCH_FN(wrapper_Meta_xlogy__Tensor)); } } // anonymous namespace namespace meta { at::Tensor xlogy(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_xlogy_Tensor(self, other); } at::Tensor & xlogy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_xlogy_out_OutTensor(self, other, out); } at::Tensor & xlogy_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_xlogy_out_OutTensor(self, other, out); } at::Tensor & xlogy_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_xlogy__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_out_logspace_out(const at::Scalar & start, const at::Scalar & end, int64_t steps, double base, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::logspace_out(start, end, steps, base, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("logspace.out", TORCH_FN(wrapper_Meta_out_logspace_out)); } } // anonymous namespace namespace meta { at::Tensor & logspace_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, int64_t steps, double base) { return wrapper_Meta_out_logspace_out(start, end, steps, base, out); } at::Tensor & logspace_outf(const at::Scalar & start, const at::Scalar & end, int64_t steps, double base, at::Tensor & out) { return wrapper_Meta_out_logspace_out(start, end, steps, base, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__log_softmax_meta_functional final : public at::meta::structured__log_softmax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__log_softmax(const at::Tensor & self, int64_t dim, bool half_to_float) { structured__log_softmax_meta_functional op; op.meta(self, dim, half_to_float); return std::move(op.outputs_[0]); } struct structured__log_softmax_meta_out final : public at::meta::structured__log_softmax { structured__log_softmax_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__log_softmax_out_out(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) { structured__log_softmax_meta_out op(out); op.meta(self, dim, half_to_float); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_log_softmax", TORCH_FN(wrapper_Meta__log_softmax)); m.impl("_log_softmax.out", TORCH_FN(wrapper_Meta__log_softmax_out_out)); } } // anonymous namespace namespace meta { at::Tensor _log_softmax(const at::Tensor & self, int64_t dim, bool half_to_float) { return wrapper_Meta__log_softmax(self, dim, half_to_float); } at::Tensor & _log_softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool half_to_float) { return wrapper_Meta__log_softmax_out_out(self, dim, half_to_float, out); } at::Tensor & _log_softmax_outf(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) { return wrapper_Meta__log_softmax_out_out(self, dim, half_to_float, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__log_softmax_backward_data_meta_functional final : public at::meta::structured__log_softmax_backward_data { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__log_softmax_backward_data(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { structured__log_softmax_backward_data_meta_functional op; op.meta(grad_output, output, dim, input_dtype); return std::move(op.outputs_[0]); } struct structured__log_softmax_backward_data_meta_out final : public at::meta::structured__log_softmax_backward_data { structured__log_softmax_backward_data_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__log_softmax_backward_data_out_out(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype, at::Tensor & out) { structured__log_softmax_backward_data_meta_out op(out); op.meta(grad_output, output, dim, input_dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_log_softmax_backward_data", TORCH_FN(wrapper_Meta__log_softmax_backward_data)); m.impl("_log_softmax_backward_data.out", TORCH_FN(wrapper_Meta__log_softmax_backward_data_out_out)); } } // anonymous namespace namespace meta { at::Tensor _log_softmax_backward_data(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { return wrapper_Meta__log_softmax_backward_data(grad_output, output, dim, input_dtype); } at::Tensor & _log_softmax_backward_data_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { return wrapper_Meta__log_softmax_backward_data_out_out(grad_output, output, dim, input_dtype, out); } at::Tensor & _log_softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype, at::Tensor & out) { return wrapper_Meta__log_softmax_backward_data_out_out(grad_output, output, dim, input_dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_aminmax_meta_functional final : public at::meta::structured_aminmax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_aminmax(const at::Tensor & self, ::std::optional dim, bool keepdim) { structured_aminmax_meta_functional op; op.meta(self, dim, keepdim); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_aminmax_meta_out final : public at::meta::structured_aminmax { structured_aminmax_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_aminmax_out_out(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & min, at::Tensor & max) { structured_aminmax_meta_out op(min, max); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(min, max); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("aminmax", TORCH_FN(wrapper_Meta_aminmax)); m.impl("aminmax.out", TORCH_FN(wrapper_Meta_aminmax_out_out)); } } // anonymous namespace namespace meta { ::std::tuple aminmax(const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_aminmax(self, dim, keepdim); } ::std::tuple aminmax_out(at::Tensor & min, at::Tensor & max, const at::Tensor & self, ::std::optional dim, bool keepdim) { return wrapper_Meta_aminmax_out_out(self, dim, keepdim, min, max); } ::std::tuple aminmax_outf(const at::Tensor & self, ::std::optional dim, bool keepdim, at::Tensor & min, at::Tensor & max) { return wrapper_Meta_aminmax_out_out(self, dim, keepdim, min, max); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_max_dim_meta_functional final : public at::meta::structured_max_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_max_dim(const at::Tensor & self, int64_t dim, bool keepdim) { structured_max_dim_meta_functional op; auto precompute = op.meta(self, dim, keepdim); (void)precompute; return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_max_dim_meta_out final : public at::meta::structured_max_dim { structured_max_dim_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_max_out_dim_max(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & max, at::Tensor & max_values) { structured_max_dim_meta_out op(max, max_values); auto precompute = op.meta(self, dim, keepdim); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(max, max_values); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("max.dim", TORCH_FN(wrapper_Meta_max_dim)); m.impl("max.dim_max", TORCH_FN(wrapper_Meta_max_out_dim_max)); } } // anonymous namespace namespace meta { ::std::tuple max(const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_max_dim(self, dim, keepdim); } ::std::tuple max_out(at::Tensor & max, at::Tensor & max_values, const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_max_out_dim_max(self, dim, keepdim, max, max_values); } ::std::tuple max_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & max, at::Tensor & max_values) { return wrapper_Meta_max_out_dim_max(self, dim, keepdim, max, max_values); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_amax_meta_functional final : public at::meta::structured_amax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_amax(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { structured_amax_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_amax_meta_out final : public at::meta::structured_amax { structured_amax_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_amax_out_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { structured_amax_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("amax", TORCH_FN(wrapper_Meta_amax)); m.impl("amax.out", TORCH_FN(wrapper_Meta_amax_out_out)); } } // anonymous namespace namespace meta { at::Tensor amax(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_amax(self, dim, keepdim); } at::Tensor & amax_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_amax_out_out(self, dim, keepdim, out); } at::Tensor & amax_outf(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_amax_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_mean_dim_meta_functional final : public at::meta::structured_mean_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_mean_dim(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { structured_mean_dim_meta_functional op; op.meta(self, dim, keepdim, dtype); return std::move(op.outputs_[0]); } struct structured_mean_dim_meta_out final : public at::meta::structured_mean_dim { structured_mean_dim_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mean_out_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { structured_mean_dim_meta_out op(out); op.meta(self, dim, keepdim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("mean.dim", TORCH_FN(wrapper_Meta_mean_dim)); m.impl("mean.out", TORCH_FN(wrapper_Meta_mean_out_out)); } } // anonymous namespace namespace meta { at::Tensor mean(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_mean_dim(self, dim, keepdim, dtype); } at::Tensor & mean_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_mean_out_out(self, dim, keepdim, dtype, out); } at::Tensor & mean_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_mean_out_out(self, dim, keepdim, dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_min_dim_meta_functional final : public at::meta::structured_min_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_min_dim(const at::Tensor & self, int64_t dim, bool keepdim) { structured_min_dim_meta_functional op; auto precompute = op.meta(self, dim, keepdim); (void)precompute; return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_min_dim_meta_out final : public at::meta::structured_min_dim { structured_min_dim_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_min_out_dim_min(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices) { structured_min_dim_meta_out op(min, min_indices); auto precompute = op.meta(self, dim, keepdim); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(min, min_indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("min.dim", TORCH_FN(wrapper_Meta_min_dim)); m.impl("min.dim_min", TORCH_FN(wrapper_Meta_min_out_dim_min)); } } // anonymous namespace namespace meta { ::std::tuple min(const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_min_dim(self, dim, keepdim); } ::std::tuple min_out(at::Tensor & min, at::Tensor & min_indices, const at::Tensor & self, int64_t dim, bool keepdim) { return wrapper_Meta_min_out_dim_min(self, dim, keepdim, min, min_indices); } ::std::tuple min_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & min, at::Tensor & min_indices) { return wrapper_Meta_min_out_dim_min(self, dim, keepdim, min, min_indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_amin_meta_functional final : public at::meta::structured_amin { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_amin(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { structured_amin_meta_functional op; op.meta(self, dim, keepdim); return std::move(op.outputs_[0]); } struct structured_amin_meta_out final : public at::meta::structured_amin { structured_amin_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_amin_out_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { structured_amin_meta_out op(out); op.meta(self, dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("amin", TORCH_FN(wrapper_Meta_amin)); m.impl("amin.out", TORCH_FN(wrapper_Meta_amin_out_out)); } } // anonymous namespace namespace meta { at::Tensor amin(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_amin(self, dim, keepdim); } at::Tensor & amin_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_amin_out_out(self, dim, keepdim, out); } at::Tensor & amin_outf(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_amin_out_out(self, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_mm_meta_functional final : public at::meta::structured_mm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_mm(const at::Tensor & self, const at::Tensor & mat2) { structured_mm_meta_functional op; op.meta(self, mat2); return std::move(op.outputs_[0]); } struct structured_mm_meta_out final : public at::meta::structured_mm { structured_mm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mm_out_out(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) { structured_mm_meta_out op(out); op.meta(self, mat2); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("mm", TORCH_FN(wrapper_Meta_mm)); m.impl("mm.out", TORCH_FN(wrapper_Meta_mm_out_out)); } } // anonymous namespace namespace meta { at::Tensor mm(const at::Tensor & self, const at::Tensor & mat2) { return wrapper_Meta_mm(self, mat2); } at::Tensor & mm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2) { return wrapper_Meta_mm_out_out(self, mat2, out); } at::Tensor & mm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out) { return wrapper_Meta_mm_out_out(self, mat2, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_mul_Tensor_meta_functional final : public at::meta::structured_mul_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_mul_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_mul_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_mul_Tensor_meta_out final : public at::meta::structured_mul_Tensor { structured_mul_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mul_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_mul_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_mul_Tensor_meta_inplace final : public at::meta::structured_mul_Tensor { structured_mul_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mul_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mul__Tensor(at::Tensor & self, const at::Tensor & other) { structured_mul_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("mul.Tensor", TORCH_FN(wrapper_Meta_mul_Tensor)); m.impl("mul.out", TORCH_FN(wrapper_Meta_mul_out_out)); m.impl("mul_.Tensor", TORCH_FN(wrapper_Meta_mul__Tensor)); } } // anonymous namespace namespace meta { at::Tensor mul(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_mul_Tensor(self, other); } at::Tensor & mul_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_mul_out_out(self, other, out); } at::Tensor & mul_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_mul_out_out(self, other, out); } at::Tensor & mul_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_mul__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_out_range_out(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::range_out(start, end, step, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("range.out", TORCH_FN(wrapper_Meta_out_range_out)); } } // anonymous namespace namespace meta { at::Tensor & range_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step) { return wrapper_Meta_out_range_out(start, end, step, out); } at::Tensor & range_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) { return wrapper_Meta_out_range_out(start, end, step, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_reciprocal_meta_functional final : public at::meta::structured_reciprocal { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_reciprocal(const at::Tensor & self) { structured_reciprocal_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_reciprocal_meta_out final : public at::meta::structured_reciprocal { structured_reciprocal_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reciprocal_out_out(const at::Tensor & self, at::Tensor & out) { structured_reciprocal_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_reciprocal_meta_inplace final : public at::meta::structured_reciprocal { structured_reciprocal_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_reciprocal::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reciprocal_(at::Tensor & self) { structured_reciprocal_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("reciprocal", TORCH_FN(wrapper_Meta_reciprocal)); m.impl("reciprocal.out", TORCH_FN(wrapper_Meta_reciprocal_out_out)); m.impl("reciprocal_", TORCH_FN(wrapper_Meta_reciprocal_)); } } // anonymous namespace namespace meta { at::Tensor reciprocal(const at::Tensor & self) { return wrapper_Meta_reciprocal(self); } at::Tensor & reciprocal_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_reciprocal_out_out(self, out); } at::Tensor & reciprocal_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_reciprocal_out_out(self, out); } at::Tensor & reciprocal_(at::Tensor & self) { return wrapper_Meta_reciprocal_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_neg_meta_functional final : public at::meta::structured_neg { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_neg(const at::Tensor & self) { structured_neg_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_neg_meta_out final : public at::meta::structured_neg { structured_neg_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_neg_out_out(const at::Tensor & self, at::Tensor & out) { structured_neg_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_neg_meta_inplace final : public at::meta::structured_neg { structured_neg_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_neg::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_neg_(at::Tensor & self) { structured_neg_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("neg", TORCH_FN(wrapper_Meta_neg)); m.impl("neg.out", TORCH_FN(wrapper_Meta_neg_out_out)); m.impl("neg_", TORCH_FN(wrapper_Meta_neg_)); } } // anonymous namespace namespace meta { at::Tensor neg(const at::Tensor & self) { return wrapper_Meta_neg(self); } at::Tensor & neg_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_neg_out_out(self, out); } at::Tensor & neg_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_neg_out_out(self, out); } at::Tensor & neg_(at::Tensor & self) { return wrapper_Meta_neg_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta___reshape_alias(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) { // No device check // DeviceGuard omitted return at::native::_reshape_alias(self, C10_AS_INTARRAYREF_SLOW(size), C10_AS_INTARRAYREF_SLOW(stride)); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_reshape_alias", TORCH_FN(wrapper_Meta___reshape_alias)); } } // anonymous namespace namespace meta { at::Tensor _reshape_alias(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride) { return wrapper_Meta___reshape_alias(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride)); } at::Tensor _reshape_alias_symint(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) { return wrapper_Meta___reshape_alias(self, size, stride); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_round_meta_functional final : public at::meta::structured_round { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_round(const at::Tensor & self) { structured_round_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_round_meta_out final : public at::meta::structured_round { structured_round_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_round_out_out(const at::Tensor & self, at::Tensor & out) { structured_round_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_round_meta_inplace final : public at::meta::structured_round { structured_round_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_round_(at::Tensor & self) { structured_round_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("round", TORCH_FN(wrapper_Meta_round)); m.impl("round.out", TORCH_FN(wrapper_Meta_round_out_out)); m.impl("round_", TORCH_FN(wrapper_Meta_round_)); } } // anonymous namespace namespace meta { at::Tensor round(const at::Tensor & self) { return wrapper_Meta_round(self); } at::Tensor & round_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_round_out_out(self, out); } at::Tensor & round_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_round_out_out(self, out); } at::Tensor & round_(at::Tensor & self) { return wrapper_Meta_round_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_round_decimals_meta_functional final : public at::meta::structured_round_decimals { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_round_decimals(const at::Tensor & self, int64_t decimals) { structured_round_decimals_meta_functional op; op.meta(self, decimals); return std::move(op.outputs_[0]); } struct structured_round_decimals_meta_out final : public at::meta::structured_round_decimals { structured_round_decimals_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_round_out_decimals_out(const at::Tensor & self, int64_t decimals, at::Tensor & out) { structured_round_decimals_meta_out op(out); op.meta(self, decimals); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_round_decimals_meta_inplace final : public at::meta::structured_round_decimals { structured_round_decimals_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_round_decimals::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_round__decimals(at::Tensor & self, int64_t decimals) { structured_round_decimals_meta_inplace op(self); op.meta(self, decimals); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("round.decimals", TORCH_FN(wrapper_Meta_round_decimals)); m.impl("round.decimals_out", TORCH_FN(wrapper_Meta_round_out_decimals_out)); m.impl("round_.decimals", TORCH_FN(wrapper_Meta_round__decimals)); } } // anonymous namespace namespace meta { at::Tensor round(const at::Tensor & self, int64_t decimals) { return wrapper_Meta_round_decimals(self, decimals); } at::Tensor & round_out(at::Tensor & out, const at::Tensor & self, int64_t decimals) { return wrapper_Meta_round_out_decimals_out(self, decimals, out); } at::Tensor & round_outf(const at::Tensor & self, int64_t decimals, at::Tensor & out) { return wrapper_Meta_round_out_decimals_out(self, decimals, out); } at::Tensor & round_(at::Tensor & self, int64_t decimals) { return wrapper_Meta_round__decimals(self, decimals); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__relu_(at::Tensor & self) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("relu_", TORCH_FN(wrapper_Meta__relu_)); } } // anonymous namespace namespace meta { at::Tensor & relu_(at::Tensor & self) { return wrapper_Meta__relu_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gelu_meta_functional final : public at::meta::structured_gelu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gelu(const at::Tensor & self, c10::string_view approximate) { structured_gelu_meta_functional op; op.meta(self, approximate); return std::move(op.outputs_[0]); } struct structured_gelu_meta_out final : public at::meta::structured_gelu { structured_gelu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gelu_out_out(const at::Tensor & self, c10::string_view approximate, at::Tensor & out) { structured_gelu_meta_out op(out); op.meta(self, approximate); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_gelu_meta_inplace final : public at::meta::structured_gelu { structured_gelu_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gelu_(at::Tensor & self, c10::string_view approximate) { structured_gelu_meta_inplace op(self); op.meta(self, approximate); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gelu", TORCH_FN(wrapper_Meta_gelu)); m.impl("gelu.out", TORCH_FN(wrapper_Meta_gelu_out_out)); m.impl("gelu_", TORCH_FN(wrapper_Meta_gelu_)); } } // anonymous namespace namespace meta { at::Tensor gelu(const at::Tensor & self, c10::string_view approximate) { return wrapper_Meta_gelu(self, approximate); } at::Tensor & gelu_out(at::Tensor & out, const at::Tensor & self, c10::string_view approximate) { return wrapper_Meta_gelu_out_out(self, approximate, out); } at::Tensor & gelu_outf(const at::Tensor & self, c10::string_view approximate, at::Tensor & out) { return wrapper_Meta_gelu_out_out(self, approximate, out); } at::Tensor & gelu_(at::Tensor & self, c10::string_view approximate) { return wrapper_Meta_gelu_(self, approximate); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gelu_backward_meta_functional final : public at::meta::structured_gelu_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gelu_backward(const at::Tensor & grad_output, const at::Tensor & self, c10::string_view approximate) { structured_gelu_backward_meta_functional op; op.meta(grad_output, self, approximate); return std::move(op.outputs_[0]); } struct structured_gelu_backward_meta_out final : public at::meta::structured_gelu_backward { structured_gelu_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gelu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gelu_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, c10::string_view approximate, at::Tensor & grad_input) { structured_gelu_backward_meta_out op(grad_input); op.meta(grad_output, self, approximate); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gelu_backward", TORCH_FN(wrapper_Meta_gelu_backward)); m.impl("gelu_backward.grad_input", TORCH_FN(wrapper_Meta_gelu_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor gelu_backward(const at::Tensor & grad_output, const at::Tensor & self, c10::string_view approximate) { return wrapper_Meta_gelu_backward(grad_output, self, approximate); } at::Tensor & gelu_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, c10::string_view approximate) { return wrapper_Meta_gelu_backward_out_grad_input(grad_output, self, approximate, grad_input); } at::Tensor & gelu_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, c10::string_view approximate, at::Tensor & grad_input) { return wrapper_Meta_gelu_backward_out_grad_input(grad_output, self, approximate, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_hardshrink_meta_functional final : public at::meta::structured_hardshrink { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_hardshrink(const at::Tensor & self, const at::Scalar & lambd) { structured_hardshrink_meta_functional op; op.meta(self, lambd); return std::move(op.outputs_[0]); } struct structured_hardshrink_meta_out final : public at::meta::structured_hardshrink { structured_hardshrink_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hardshrink_out_out(const at::Tensor & self, const at::Scalar & lambd, at::Tensor & out) { structured_hardshrink_meta_out op(out); op.meta(self, lambd); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardshrink", TORCH_FN(wrapper_Meta_hardshrink)); m.impl("hardshrink.out", TORCH_FN(wrapper_Meta_hardshrink_out_out)); } } // anonymous namespace namespace meta { at::Tensor hardshrink(const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_hardshrink(self, lambd); } at::Tensor & hardshrink_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_hardshrink_out_out(self, lambd, out); } at::Tensor & hardshrink_outf(const at::Tensor & self, const at::Scalar & lambd, at::Tensor & out) { return wrapper_Meta_hardshrink_out_out(self, lambd, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_hardshrink_backward_meta_functional final : public at::meta::structured_hardshrink_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_hardshrink_backward(const at::Tensor & grad_out, const at::Tensor & self, const at::Scalar & lambd) { structured_hardshrink_backward_meta_functional op; op.meta(grad_out, self, lambd); return std::move(op.outputs_[0]); } struct structured_hardshrink_backward_meta_out final : public at::meta::structured_hardshrink_backward { structured_hardshrink_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hardshrink_backward_out_grad_input(const at::Tensor & grad_out, const at::Tensor & self, const at::Scalar & lambd, at::Tensor & grad_input) { structured_hardshrink_backward_meta_out op(grad_input); op.meta(grad_out, self, lambd); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardshrink_backward", TORCH_FN(wrapper_Meta_hardshrink_backward)); m.impl("hardshrink_backward.grad_input", TORCH_FN(wrapper_Meta_hardshrink_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor hardshrink_backward(const at::Tensor & grad_out, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_hardshrink_backward(grad_out, self, lambd); } at::Tensor & hardshrink_backward_out(at::Tensor & grad_input, const at::Tensor & grad_out, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_hardshrink_backward_out_grad_input(grad_out, self, lambd, grad_input); } at::Tensor & hardshrink_backward_outf(const at::Tensor & grad_out, const at::Tensor & self, const at::Scalar & lambd, at::Tensor & grad_input) { return wrapper_Meta_hardshrink_backward_out_grad_input(grad_out, self, lambd, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_rsqrt_meta_functional final : public at::meta::structured_rsqrt { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_rsqrt(const at::Tensor & self) { structured_rsqrt_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_rsqrt_meta_out final : public at::meta::structured_rsqrt { structured_rsqrt_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_rsqrt_out_out(const at::Tensor & self, at::Tensor & out) { structured_rsqrt_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_rsqrt_meta_inplace final : public at::meta::structured_rsqrt { structured_rsqrt_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_rsqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_rsqrt_(at::Tensor & self) { structured_rsqrt_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("rsqrt", TORCH_FN(wrapper_Meta_rsqrt)); m.impl("rsqrt.out", TORCH_FN(wrapper_Meta_rsqrt_out_out)); m.impl("rsqrt_", TORCH_FN(wrapper_Meta_rsqrt_)); } } // anonymous namespace namespace meta { at::Tensor rsqrt(const at::Tensor & self) { return wrapper_Meta_rsqrt(self); } at::Tensor & rsqrt_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_rsqrt_out_out(self, out); } at::Tensor & rsqrt_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_rsqrt_out_out(self, out); } at::Tensor & rsqrt_(at::Tensor & self) { return wrapper_Meta_rsqrt_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_silu_meta_functional final : public at::meta::structured_silu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_silu(const at::Tensor & self) { structured_silu_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_silu_meta_out final : public at::meta::structured_silu { structured_silu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_silu_out_out(const at::Tensor & self, at::Tensor & out) { structured_silu_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_silu_meta_inplace final : public at::meta::structured_silu { structured_silu_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_silu_(at::Tensor & self) { structured_silu_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("silu", TORCH_FN(wrapper_Meta_silu)); m.impl("silu.out", TORCH_FN(wrapper_Meta_silu_out_out)); m.impl("silu_", TORCH_FN(wrapper_Meta_silu_)); } } // anonymous namespace namespace meta { at::Tensor silu(const at::Tensor & self) { return wrapper_Meta_silu(self); } at::Tensor & silu_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_silu_out_out(self, out); } at::Tensor & silu_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_silu_out_out(self, out); } at::Tensor & silu_(at::Tensor & self) { return wrapper_Meta_silu_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_silu_backward_meta_functional final : public at::meta::structured_silu_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_silu_backward(const at::Tensor & grad_output, const at::Tensor & self) { structured_silu_backward_meta_functional op; op.meta(grad_output, self); return std::move(op.outputs_[0]); } struct structured_silu_backward_meta_out final : public at::meta::structured_silu_backward { structured_silu_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_silu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_silu_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & grad_input) { structured_silu_backward_meta_out op(grad_input); op.meta(grad_output, self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("silu_backward", TORCH_FN(wrapper_Meta_silu_backward)); m.impl("silu_backward.grad_input", TORCH_FN(wrapper_Meta_silu_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor silu_backward(const at::Tensor & grad_output, const at::Tensor & self) { return wrapper_Meta_silu_backward(grad_output, self); } at::Tensor & silu_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self) { return wrapper_Meta_silu_backward_out_grad_input(grad_output, self, grad_input); } at::Tensor & silu_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & grad_input) { return wrapper_Meta_silu_backward_out_grad_input(grad_output, self, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_mish_meta_functional final : public at::meta::structured_mish { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_mish(const at::Tensor & self) { structured_mish_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_mish_meta_out final : public at::meta::structured_mish { structured_mish_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mish_out_out(const at::Tensor & self, at::Tensor & out) { structured_mish_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_mish_meta_inplace final : public at::meta::structured_mish { structured_mish_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mish::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mish_(at::Tensor & self) { structured_mish_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("mish", TORCH_FN(wrapper_Meta_mish)); m.impl("mish.out", TORCH_FN(wrapper_Meta_mish_out_out)); m.impl("mish_", TORCH_FN(wrapper_Meta_mish_)); } } // anonymous namespace namespace meta { at::Tensor mish(const at::Tensor & self) { return wrapper_Meta_mish(self); } at::Tensor & mish_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_mish_out_out(self, out); } at::Tensor & mish_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_mish_out_out(self, out); } at::Tensor & mish_(at::Tensor & self) { return wrapper_Meta_mish_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sigmoid_meta_functional final : public at::meta::structured_sigmoid { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sigmoid(const at::Tensor & self) { structured_sigmoid_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sigmoid_meta_out final : public at::meta::structured_sigmoid { structured_sigmoid_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sigmoid_out_out(const at::Tensor & self, at::Tensor & out) { structured_sigmoid_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sigmoid_meta_inplace final : public at::meta::structured_sigmoid { structured_sigmoid_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sigmoid_(at::Tensor & self) { structured_sigmoid_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sigmoid", TORCH_FN(wrapper_Meta_sigmoid)); m.impl("sigmoid.out", TORCH_FN(wrapper_Meta_sigmoid_out_out)); m.impl("sigmoid_", TORCH_FN(wrapper_Meta_sigmoid_)); } } // anonymous namespace namespace meta { at::Tensor sigmoid(const at::Tensor & self) { return wrapper_Meta_sigmoid(self); } at::Tensor & sigmoid_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sigmoid_out_out(self, out); } at::Tensor & sigmoid_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sigmoid_out_out(self, out); } at::Tensor & sigmoid_(at::Tensor & self) { return wrapper_Meta_sigmoid_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__logit_(at::Tensor & self, ::std::optional eps) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("logit_", TORCH_FN(wrapper_Meta__logit_)); } } // anonymous namespace namespace meta { at::Tensor & logit_(at::Tensor & self, ::std::optional eps) { return wrapper_Meta__logit_(self, eps); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sin_meta_functional final : public at::meta::structured_sin { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sin(const at::Tensor & self) { structured_sin_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sin_meta_out final : public at::meta::structured_sin { structured_sin_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sin_out_out(const at::Tensor & self, at::Tensor & out) { structured_sin_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sin_meta_inplace final : public at::meta::structured_sin { structured_sin_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sin_(at::Tensor & self) { structured_sin_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sin", TORCH_FN(wrapper_Meta_sin)); m.impl("sin.out", TORCH_FN(wrapper_Meta_sin_out_out)); m.impl("sin_", TORCH_FN(wrapper_Meta_sin_)); } } // anonymous namespace namespace meta { at::Tensor sin(const at::Tensor & self) { return wrapper_Meta_sin(self); } at::Tensor & sin_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sin_out_out(self, out); } at::Tensor & sin_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sin_out_out(self, out); } at::Tensor & sin_(at::Tensor & self) { return wrapper_Meta_sin_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sinc_meta_functional final : public at::meta::structured_sinc { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sinc(const at::Tensor & self) { structured_sinc_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sinc_meta_out final : public at::meta::structured_sinc { structured_sinc_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sinc_out_out(const at::Tensor & self, at::Tensor & out) { structured_sinc_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sinc_meta_inplace final : public at::meta::structured_sinc { structured_sinc_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sinc_(at::Tensor & self) { structured_sinc_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sinc", TORCH_FN(wrapper_Meta_sinc)); m.impl("sinc.out", TORCH_FN(wrapper_Meta_sinc_out_out)); m.impl("sinc_", TORCH_FN(wrapper_Meta_sinc_)); } } // anonymous namespace namespace meta { at::Tensor sinc(const at::Tensor & self) { return wrapper_Meta_sinc(self); } at::Tensor & sinc_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sinc_out_out(self, out); } at::Tensor & sinc_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sinc_out_out(self, out); } at::Tensor & sinc_(at::Tensor & self) { return wrapper_Meta_sinc_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sinh_meta_functional final : public at::meta::structured_sinh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sinh(const at::Tensor & self) { structured_sinh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sinh_meta_out final : public at::meta::structured_sinh { structured_sinh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sinh_out_out(const at::Tensor & self, at::Tensor & out) { structured_sinh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sinh_meta_inplace final : public at::meta::structured_sinh { structured_sinh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sinh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sinh_(at::Tensor & self) { structured_sinh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sinh", TORCH_FN(wrapper_Meta_sinh)); m.impl("sinh.out", TORCH_FN(wrapper_Meta_sinh_out_out)); m.impl("sinh_", TORCH_FN(wrapper_Meta_sinh_)); } } // anonymous namespace namespace meta { at::Tensor sinh(const at::Tensor & self) { return wrapper_Meta_sinh(self); } at::Tensor & sinh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sinh_out_out(self, out); } at::Tensor & sinh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sinh_out_out(self, out); } at::Tensor & sinh_(at::Tensor & self) { return wrapper_Meta_sinh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__softmax_meta_functional final : public at::meta::structured__softmax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__softmax(const at::Tensor & self, int64_t dim, bool half_to_float) { structured__softmax_meta_functional op; op.meta(self, dim, half_to_float); return std::move(op.outputs_[0]); } struct structured__softmax_meta_out final : public at::meta::structured__softmax { structured__softmax_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__softmax_out_out(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) { structured__softmax_meta_out op(out); op.meta(self, dim, half_to_float); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_softmax", TORCH_FN(wrapper_Meta__softmax)); m.impl("_softmax.out", TORCH_FN(wrapper_Meta__softmax_out_out)); } } // anonymous namespace namespace meta { at::Tensor _softmax(const at::Tensor & self, int64_t dim, bool half_to_float) { return wrapper_Meta__softmax(self, dim, half_to_float); } at::Tensor & _softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool half_to_float) { return wrapper_Meta__softmax_out_out(self, dim, half_to_float, out); } at::Tensor & _softmax_outf(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) { return wrapper_Meta__softmax_out_out(self, dim, half_to_float, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__softmax_backward_data_meta_functional final : public at::meta::structured__softmax_backward_data { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__softmax_backward_data(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { structured__softmax_backward_data_meta_functional op; op.meta(grad_output, output, dim, input_dtype); return std::move(op.outputs_[0]); } struct structured__softmax_backward_data_meta_out final : public at::meta::structured__softmax_backward_data { structured__softmax_backward_data_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__softmax_backward_data_out_out(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype, at::Tensor & grad_input) { structured__softmax_backward_data_meta_out op(grad_input); op.meta(grad_output, output, dim, input_dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_softmax_backward_data", TORCH_FN(wrapper_Meta__softmax_backward_data)); m.impl("_softmax_backward_data.out", TORCH_FN(wrapper_Meta__softmax_backward_data_out_out)); } } // anonymous namespace namespace meta { at::Tensor _softmax_backward_data(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { return wrapper_Meta__softmax_backward_data(grad_output, output, dim, input_dtype); } at::Tensor & _softmax_backward_data_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype) { return wrapper_Meta__softmax_backward_data_out_out(grad_output, output, dim, input_dtype, grad_input); } at::Tensor & _softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, at::ScalarType input_dtype, at::Tensor & grad_input) { return wrapper_Meta__softmax_backward_data_out_out(grad_output, output, dim, input_dtype, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sum_dim_IntList_meta_functional final : public at::meta::structured_sum_dim_IntList { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sum_dim_IntList(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { structured_sum_dim_IntList_meta_functional op; op.meta(self, dim, keepdim, dtype); return std::move(op.outputs_[0]); } struct structured_sum_dim_IntList_meta_out final : public at::meta::structured_sum_dim_IntList { structured_sum_dim_IntList_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sum_out_IntList_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { structured_sum_dim_IntList_meta_out op(out); op.meta(self, dim, keepdim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sum.dim_IntList", TORCH_FN(wrapper_Meta_sum_dim_IntList)); m.impl("sum.IntList_out", TORCH_FN(wrapper_Meta_sum_out_IntList_out)); } } // anonymous namespace namespace meta { at::Tensor sum(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_sum_dim_IntList(self, dim, keepdim, dtype); } at::Tensor & sum_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_sum_out_IntList_out(self, dim, keepdim, dtype, out); } at::Tensor & sum_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_sum_out_IntList_out(self, dim, keepdim, dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sqrt_meta_functional final : public at::meta::structured_sqrt { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sqrt(const at::Tensor & self) { structured_sqrt_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sqrt_meta_out final : public at::meta::structured_sqrt { structured_sqrt_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sqrt_out_out(const at::Tensor & self, at::Tensor & out) { structured_sqrt_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sqrt_meta_inplace final : public at::meta::structured_sqrt { structured_sqrt_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sqrt::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sqrt_(at::Tensor & self) { structured_sqrt_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sqrt", TORCH_FN(wrapper_Meta_sqrt)); m.impl("sqrt.out", TORCH_FN(wrapper_Meta_sqrt_out_out)); m.impl("sqrt_", TORCH_FN(wrapper_Meta_sqrt_)); } } // anonymous namespace namespace meta { at::Tensor sqrt(const at::Tensor & self) { return wrapper_Meta_sqrt(self); } at::Tensor & sqrt_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sqrt_out_out(self, out); } at::Tensor & sqrt_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sqrt_out_out(self, out); } at::Tensor & sqrt_(at::Tensor & self) { return wrapper_Meta_sqrt_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_prod_dim_int_meta_functional final : public at::meta::structured_prod_dim_int { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_prod_dim_int(const at::Tensor & self, int64_t dim, bool keepdim, ::std::optional dtype) { structured_prod_dim_int_meta_functional op; op.meta(self, dim, keepdim, dtype); return std::move(op.outputs_[0]); } struct structured_prod_dim_int_meta_out final : public at::meta::structured_prod_dim_int { structured_prod_dim_int_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_prod_out_int_out(const at::Tensor & self, int64_t dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { structured_prod_dim_int_meta_out op(out); op.meta(self, dim, keepdim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("prod.dim_int", TORCH_FN(wrapper_Meta_prod_dim_int)); m.impl("prod.int_out", TORCH_FN(wrapper_Meta_prod_out_int_out)); } } // anonymous namespace namespace meta { at::Tensor prod(const at::Tensor & self, int64_t dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_prod_dim_int(self, dim, keepdim, dtype); } at::Tensor & prod_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_prod_out_int_out(self, dim, keepdim, dtype, out); } at::Tensor & prod_outf(const at::Tensor & self, int64_t dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_prod_out_int_out(self, dim, keepdim, dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_tan_meta_functional final : public at::meta::structured_tan { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_tan(const at::Tensor & self) { structured_tan_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_tan_meta_out final : public at::meta::structured_tan { structured_tan_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tan_out_out(const at::Tensor & self, at::Tensor & out) { structured_tan_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_tan_meta_inplace final : public at::meta::structured_tan { structured_tan_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tan::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tan_(at::Tensor & self) { structured_tan_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("tan", TORCH_FN(wrapper_Meta_tan)); m.impl("tan.out", TORCH_FN(wrapper_Meta_tan_out_out)); m.impl("tan_", TORCH_FN(wrapper_Meta_tan_)); } } // anonymous namespace namespace meta { at::Tensor tan(const at::Tensor & self) { return wrapper_Meta_tan(self); } at::Tensor & tan_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_tan_out_out(self, out); } at::Tensor & tan_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_tan_out_out(self, out); } at::Tensor & tan_(at::Tensor & self) { return wrapper_Meta_tan_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_tanh_meta_functional final : public at::meta::structured_tanh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_tanh(const at::Tensor & self) { structured_tanh_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_tanh_meta_out final : public at::meta::structured_tanh { structured_tanh_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tanh_out_out(const at::Tensor & self, at::Tensor & out) { structured_tanh_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_tanh_meta_inplace final : public at::meta::structured_tanh { structured_tanh_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tanh_(at::Tensor & self) { structured_tanh_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("tanh", TORCH_FN(wrapper_Meta_tanh)); m.impl("tanh.out", TORCH_FN(wrapper_Meta_tanh_out_out)); m.impl("tanh_", TORCH_FN(wrapper_Meta_tanh_)); } } // anonymous namespace namespace meta { at::Tensor tanh(const at::Tensor & self) { return wrapper_Meta_tanh(self); } at::Tensor & tanh_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_tanh_out_out(self, out); } at::Tensor & tanh_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_tanh_out_out(self, out); } at::Tensor & tanh_(at::Tensor & self) { return wrapper_Meta_tanh_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_threshold_meta_functional final : public at::meta::structured_threshold { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_threshold(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { structured_threshold_meta_functional op; op.meta(self, threshold, value); return std::move(op.outputs_[0]); } struct structured_threshold_meta_out final : public at::meta::structured_threshold { structured_threshold_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_threshold_out_out(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value, at::Tensor & out) { structured_threshold_meta_out op(out); op.meta(self, threshold, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_threshold_meta_inplace final : public at::meta::structured_threshold { structured_threshold_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_threshold_(at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { structured_threshold_meta_inplace op(self); op.meta(self, threshold, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("threshold", TORCH_FN(wrapper_Meta_threshold)); m.impl("threshold.out", TORCH_FN(wrapper_Meta_threshold_out_out)); m.impl("threshold_", TORCH_FN(wrapper_Meta_threshold_)); } } // anonymous namespace namespace meta { at::Tensor threshold(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { return wrapper_Meta_threshold(self, threshold, value); } at::Tensor & threshold_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { return wrapper_Meta_threshold_out_out(self, threshold, value, out); } at::Tensor & threshold_outf(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value, at::Tensor & out) { return wrapper_Meta_threshold_out_out(self, threshold, value, out); } at::Tensor & threshold_(at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { return wrapper_Meta_threshold_(self, threshold, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_threshold_backward_meta_functional final : public at::meta::structured_threshold_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_threshold_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & threshold) { structured_threshold_backward_meta_functional op; op.meta(grad_output, self, threshold); return std::move(op.outputs_[0]); } struct structured_threshold_backward_meta_out final : public at::meta::structured_threshold_backward { structured_threshold_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_threshold_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_threshold_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & threshold, at::Tensor & grad_input) { structured_threshold_backward_meta_out op(grad_input); op.meta(grad_output, self, threshold); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("threshold_backward", TORCH_FN(wrapper_Meta_threshold_backward)); m.impl("threshold_backward.grad_input", TORCH_FN(wrapper_Meta_threshold_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor threshold_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & threshold) { return wrapper_Meta_threshold_backward(grad_output, self, threshold); } at::Tensor & threshold_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & threshold) { return wrapper_Meta_threshold_backward_out_grad_input(grad_output, self, threshold, grad_input); } at::Tensor & threshold_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & threshold, at::Tensor & grad_input) { return wrapper_Meta_threshold_backward_out_grad_input(grad_output, self, threshold, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta___mkldnn_transpose_(at::Tensor & self, int64_t dim0, int64_t dim1) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_mkldnn_transpose_", TORCH_FN(wrapper_Meta___mkldnn_transpose_)); } } // anonymous namespace namespace meta { at::Tensor & _mkldnn_transpose_(at::Tensor & self, int64_t dim0, int64_t dim1) { return wrapper_Meta___mkldnn_transpose_(self, dim0, dim1); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_trunc_meta_functional final : public at::meta::structured_trunc { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_trunc(const at::Tensor & self) { structured_trunc_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_trunc_meta_out final : public at::meta::structured_trunc { structured_trunc_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_trunc_out_out(const at::Tensor & self, at::Tensor & out) { structured_trunc_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_trunc_meta_inplace final : public at::meta::structured_trunc { structured_trunc_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_trunc::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_trunc_(at::Tensor & self) { structured_trunc_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("trunc", TORCH_FN(wrapper_Meta_trunc)); m.impl("trunc.out", TORCH_FN(wrapper_Meta_trunc_out_out)); m.impl("trunc_", TORCH_FN(wrapper_Meta_trunc_)); } } // anonymous namespace namespace meta { at::Tensor trunc(const at::Tensor & self) { return wrapper_Meta_trunc(self); } at::Tensor & trunc_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_trunc_out_out(self, out); } at::Tensor & trunc_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_trunc_out_out(self, out); } at::Tensor & trunc_(at::Tensor & self) { return wrapper_Meta_trunc_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta___efficientzerotensor(c10::SymIntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { // No device check // DeviceGuard omitted return at::native::_efficientzerotensor_meta_symint(size, dtype, layout, device, pin_memory); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_efficientzerotensor", TORCH_FN(wrapper_Meta___efficientzerotensor)); } } // anonymous namespace namespace meta { at::Tensor _efficientzerotensor(at::IntArrayRef size, at::TensorOptions options) { return wrapper_Meta___efficientzerotensor(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); } at::Tensor _efficientzerotensor(at::IntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { return wrapper_Meta___efficientzerotensor(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory); } at::Tensor _efficientzerotensor_symint(c10::SymIntArrayRef size, at::TensorOptions options) { return wrapper_Meta___efficientzerotensor(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); } at::Tensor _efficientzerotensor_symint(c10::SymIntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { return wrapper_Meta___efficientzerotensor(size, dtype, layout, device, pin_memory); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_norm_ScalarOpt_dim_dtype_meta_functional final : public at::meta::structured_norm_ScalarOpt_dim_dtype { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_norm_ScalarOpt_dim_dtype(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype) { structured_norm_ScalarOpt_dim_dtype_meta_functional op; op.meta(self, (p.has_value() ? at::OptionalScalarRef(&(p.value())) : at::OptionalScalarRef()), dim, keepdim, dtype); return std::move(op.outputs_[0]); } struct structured_norm_ScalarOpt_dim_dtype_meta_out final : public at::meta::structured_norm_ScalarOpt_dim_dtype { structured_norm_ScalarOpt_dim_dtype_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_norm_out_dtype_out(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype, at::Tensor & out) { structured_norm_ScalarOpt_dim_dtype_meta_out op(out); op.meta(self, (p.has_value() ? at::OptionalScalarRef(&(p.value())) : at::OptionalScalarRef()), dim, keepdim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("norm.ScalarOpt_dim_dtype", TORCH_FN(wrapper_Meta_norm_ScalarOpt_dim_dtype)); m.impl("norm.dtype_out", TORCH_FN(wrapper_Meta_norm_out_dtype_out)); } } // anonymous namespace namespace meta { at::Tensor norm(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype) { return wrapper_Meta_norm_ScalarOpt_dim_dtype(self, p, dim, keepdim, dtype); } at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype) { return wrapper_Meta_norm_out_dtype_out(self, p, dim, keepdim, dtype, out); } at::Tensor & norm_outf(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype, at::Tensor & out) { return wrapper_Meta_norm_out_dtype_out(self, p, dim, keepdim, dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_norm_ScalarOpt_dim_meta_functional final : public at::meta::structured_norm_ScalarOpt_dim { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_norm_ScalarOpt_dim(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim) { structured_norm_ScalarOpt_dim_meta_functional op; op.meta(self, (p.has_value() ? at::OptionalScalarRef(&(p.value())) : at::OptionalScalarRef()), dim, keepdim); return std::move(op.outputs_[0]); } struct structured_norm_ScalarOpt_dim_meta_out final : public at::meta::structured_norm_ScalarOpt_dim { structured_norm_ScalarOpt_dim_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_norm_out_out(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { structured_norm_ScalarOpt_dim_meta_out op(out); op.meta(self, (p.has_value() ? at::OptionalScalarRef(&(p.value())) : at::OptionalScalarRef()), dim, keepdim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("norm.ScalarOpt_dim", TORCH_FN(wrapper_Meta_norm_ScalarOpt_dim)); m.impl("norm.out", TORCH_FN(wrapper_Meta_norm_out_out)); } } // anonymous namespace namespace meta { at::Tensor norm(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_norm_ScalarOpt_dim(self, p, dim, keepdim); } at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim) { return wrapper_Meta_norm_out_out(self, p, dim, keepdim, out); } at::Tensor & norm_outf(const at::Tensor & self, const ::std::optional & p, at::IntArrayRef dim, bool keepdim, at::Tensor & out) { return wrapper_Meta_norm_out_out(self, p, dim, keepdim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { const at::Tensor & wrapper_Meta__resize_as_sparse_(const at::Tensor & self, const at::Tensor & the_template) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("resize_as_sparse_", TORCH_FN(wrapper_Meta__resize_as_sparse_)); } } // anonymous namespace namespace meta { const at::Tensor & resize_as_sparse_(const at::Tensor & self, const at::Tensor & the_template) { return wrapper_Meta__resize_as_sparse_(self, the_template); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta__zero_(at::Tensor & self) { // No device check // DeviceGuard omitted return at::native::zero_meta_(self); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("zero_", TORCH_FN(wrapper_Meta__zero_)); } } // anonymous namespace namespace meta { at::Tensor & zero_(at::Tensor & self) { return wrapper_Meta__zero_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sub_Tensor_meta_functional final : public at::meta::structured_sub_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sub_Tensor(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { structured_sub_Tensor_meta_functional op; op.meta(self, other, alpha); return std::move(op.outputs_[0]); } struct structured_sub_Tensor_meta_out final : public at::meta::structured_sub_Tensor { structured_sub_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sub_out_out(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) { structured_sub_Tensor_meta_out op(out); op.meta(self, other, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sub_Tensor_meta_inplace final : public at::meta::structured_sub_Tensor { structured_sub_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sub_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sub__Tensor(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { structured_sub_Tensor_meta_inplace op(self); op.meta(self, other, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sub.Tensor", TORCH_FN(wrapper_Meta_sub_Tensor)); m.impl("sub.out", TORCH_FN(wrapper_Meta_sub_out_out)); m.impl("sub_.Tensor", TORCH_FN(wrapper_Meta_sub__Tensor)); } } // anonymous namespace namespace meta { at::Tensor sub(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_sub_Tensor(self, other, alpha); } at::Tensor & sub_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_sub_out_out(self, other, alpha, out); } at::Tensor & sub_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_sub_out_out(self, other, alpha, out); } at::Tensor & sub_(at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) { return wrapper_Meta_sub__Tensor(self, other, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_heaviside_meta_functional final : public at::meta::structured_heaviside { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_heaviside(const at::Tensor & self, const at::Tensor & values) { structured_heaviside_meta_functional op; op.meta(self, values); return std::move(op.outputs_[0]); } struct structured_heaviside_meta_out final : public at::meta::structured_heaviside { structured_heaviside_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_heaviside_out_out(const at::Tensor & self, const at::Tensor & values, at::Tensor & out) { structured_heaviside_meta_out op(out); op.meta(self, values); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_heaviside_meta_inplace final : public at::meta::structured_heaviside { structured_heaviside_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_heaviside::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_heaviside_(at::Tensor & self, const at::Tensor & values) { structured_heaviside_meta_inplace op(self); op.meta(self, values); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("heaviside", TORCH_FN(wrapper_Meta_heaviside)); m.impl("heaviside.out", TORCH_FN(wrapper_Meta_heaviside_out_out)); m.impl("heaviside_", TORCH_FN(wrapper_Meta_heaviside_)); } } // anonymous namespace namespace meta { at::Tensor heaviside(const at::Tensor & self, const at::Tensor & values) { return wrapper_Meta_heaviside(self, values); } at::Tensor & heaviside_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & values) { return wrapper_Meta_heaviside_out_out(self, values, out); } at::Tensor & heaviside_outf(const at::Tensor & self, const at::Tensor & values, at::Tensor & out) { return wrapper_Meta_heaviside_out_out(self, values, out); } at::Tensor & heaviside_(at::Tensor & self, const at::Tensor & values) { return wrapper_Meta_heaviside_(self, values); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_addmm_meta_functional final : public at::meta::structured_addmm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_addmm(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) { structured_addmm_meta_functional op; op.meta(self, mat1, mat2, beta, alpha); return std::move(op.outputs_[0]); } struct structured_addmm_meta_out final : public at::meta::structured_addmm { structured_addmm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addmm_out_out(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { structured_addmm_meta_out op(out); op.meta(self, mat1, mat2, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_addmm_meta_inplace final : public at::meta::structured_addmm { structured_addmm_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addmm_(at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) { structured_addmm_meta_inplace op(self); op.meta(self, mat1, mat2, beta, alpha); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("addmm", TORCH_FN(wrapper_Meta_addmm)); m.impl("addmm.out", TORCH_FN(wrapper_Meta_addmm_out_out)); m.impl("addmm_", TORCH_FN(wrapper_Meta_addmm_)); } } // anonymous namespace namespace meta { at::Tensor addmm(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmm(self, mat1, mat2, beta, alpha); } at::Tensor & addmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmm_out_out(self, mat1, mat2, beta, alpha, out); } at::Tensor & addmm_outf(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_addmm_out_out(self, mat1, mat2, beta, alpha, out); } at::Tensor & addmm_(at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta_addmm_(self, mat1, mat2, beta, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__addmm_activation_meta_functional final : public at::meta::structured__addmm_activation { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__addmm_activation(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu) { structured__addmm_activation_meta_functional op; op.meta(self, mat1, mat2, beta, alpha, use_gelu); return std::move(op.outputs_[0]); } struct structured__addmm_activation_meta_out final : public at::meta::structured__addmm_activation { structured__addmm_activation_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__addmm_activation_out_out(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu, at::Tensor & out) { structured__addmm_activation_meta_out op(out); op.meta(self, mat1, mat2, beta, alpha, use_gelu); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_addmm_activation", TORCH_FN(wrapper_Meta__addmm_activation)); m.impl("_addmm_activation.out", TORCH_FN(wrapper_Meta__addmm_activation_out_out)); } } // anonymous namespace namespace meta { at::Tensor _addmm_activation(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu) { return wrapper_Meta__addmm_activation(self, mat1, mat2, beta, alpha, use_gelu); } at::Tensor & _addmm_activation_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu) { return wrapper_Meta__addmm_activation_out_out(self, mat1, mat2, beta, alpha, use_gelu, out); } at::Tensor & _addmm_activation_outf(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, bool use_gelu, at::Tensor & out) { return wrapper_Meta__addmm_activation_out_out(self, mat1, mat2, beta, alpha, use_gelu, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta___sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { // No device check // DeviceGuard omitted return at::native::new_with_dims_sparse(sparse_dim, dense_dim, size, dtype, layout, device, pin_memory); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_sparse_coo_tensor_with_dims", TORCH_FN(wrapper_Meta___sparse_coo_tensor_with_dims)); } } // anonymous namespace namespace meta { at::Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, at::TensorOptions options) { return wrapper_Meta___sparse_coo_tensor_with_dims(sparse_dim, dense_dim, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); } at::Tensor _sparse_coo_tensor_with_dims(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory) { return wrapper_Meta___sparse_coo_tensor_with_dims(sparse_dim, dense_dim, size, dtype, layout, device, pin_memory); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional is_coalesced) { // No device check // DeviceGuard omitted return at::native::new_with_dims_and_tensor_sparse_symint(sparse_dim, dense_dim, size, indices, values, dtype, layout, device, pin_memory, is_coalesced); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_sparse_coo_tensor_with_dims_and_tensors", TORCH_FN(wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors)); } } // anonymous namespace namespace meta { at::Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, const at::Tensor & indices, const at::Tensor & values, at::TensorOptions options, ::std::optional is_coalesced) { return wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, c10::fromIntArrayRefSlow(size), indices, values, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), is_coalesced); } at::Tensor _sparse_coo_tensor_with_dims_and_tensors(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional is_coalesced) { return wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, c10::fromIntArrayRefSlow(size), indices, values, dtype, layout, device, pin_memory, is_coalesced); } at::Tensor _sparse_coo_tensor_with_dims_and_tensors_symint(int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, at::TensorOptions options, ::std::optional is_coalesced) { return wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, size, indices, values, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), is_coalesced); } at::Tensor _sparse_coo_tensor_with_dims_and_tensors_symint(int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional dtype, ::std::optional layout, ::std::optional device, ::std::optional pin_memory, ::std::optional is_coalesced) { return wrapper_Meta___sparse_coo_tensor_with_dims_and_tensors(sparse_dim, dense_dim, size, indices, values, dtype, layout, device, pin_memory, is_coalesced); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { const at::Tensor & wrapper_Meta__sparse_resize_(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sparse_resize_", TORCH_FN(wrapper_Meta__sparse_resize_)); } } // anonymous namespace namespace meta { const at::Tensor & sparse_resize_(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { return wrapper_Meta__sparse_resize_(self, size, sparse_dim, dense_dim); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { const at::Tensor & wrapper_Meta__sparse_resize_and_clear_(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sparse_resize_and_clear_", TORCH_FN(wrapper_Meta__sparse_resize_and_clear_)); } } // anonymous namespace namespace meta { const at::Tensor & sparse_resize_and_clear_(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) { return wrapper_Meta__sparse_resize_and_clear_(self, size, sparse_dim, dense_dim); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta___coalesced_(at::Tensor & self, bool coalesced) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_coalesced_", TORCH_FN(wrapper_Meta___coalesced_)); } } // anonymous namespace namespace meta { at::Tensor & _coalesced_(at::Tensor & self, bool coalesced) { return wrapper_Meta___coalesced_(self, coalesced); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__copy_sparse_to_sparse_(at::Tensor & self, const at::Tensor & src, bool non_blocking) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("copy_sparse_to_sparse_", TORCH_FN(wrapper_Meta__copy_sparse_to_sparse_)); } } // anonymous namespace namespace meta { at::Tensor & copy_sparse_to_sparse_(at::Tensor & self, const at::Tensor & src, bool non_blocking) { return wrapper_Meta__copy_sparse_to_sparse_(self, src, non_blocking); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_source_Storage_set_(at::Tensor & self, at::Storage source) { // No device check // DeviceGuard omitted return at::native::set_(self, source); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("set_.source_Storage", TORCH_FN(wrapper_Meta_source_Storage_set_)); } } // anonymous namespace namespace meta { at::Tensor & set_(at::Tensor & self, at::Storage source) { return wrapper_Meta_source_Storage_set_(self, source); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_source_Storage_storage_offset_set_(at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) { // No device check // DeviceGuard omitted return at::native::set_storage_meta__symint(self, source, storage_offset, size, stride); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("set_.source_Storage_storage_offset", TORCH_FN(wrapper_Meta_source_Storage_storage_offset_set_)); } } // anonymous namespace namespace meta { at::Tensor & set_(at::Tensor & self, at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride) { return wrapper_Meta_source_Storage_storage_offset_set_(self, source, storage_offset, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride)); } at::Tensor & set__symint(at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) { return wrapper_Meta_source_Storage_storage_offset_set_(self, source, storage_offset, size, stride); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_source_Tensor_set_(at::Tensor & self, const at::Tensor & source) { // No device check // DeviceGuard omitted return at::native::set_tensor_(self, source); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("set_.source_Tensor", TORCH_FN(wrapper_Meta_source_Tensor_set_)); } } // anonymous namespace namespace meta { at::Tensor & set_(at::Tensor & self, const at::Tensor & source) { return wrapper_Meta_source_Tensor_set_(self, source); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta__set_(at::Tensor & self) { // No device check // DeviceGuard omitted return at::native::set_meta_(self); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("set_", TORCH_FN(wrapper_Meta__set_)); } } // anonymous namespace namespace meta { at::Tensor & set_(at::Tensor & self) { return wrapper_Meta__set_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Scalar_masked_fill_(at::Tensor & self, const at::Tensor & mask, const at::Scalar & value) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("masked_fill_.Scalar", TORCH_FN(wrapper_Meta_Scalar_masked_fill_)); } } // anonymous namespace namespace meta { at::Tensor & masked_fill_(at::Tensor & self, const at::Tensor & mask, const at::Scalar & value) { return wrapper_Meta_Scalar_masked_fill_(self, mask, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor_masked_fill_(at::Tensor & self, const at::Tensor & mask, const at::Tensor & value) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("masked_fill_.Tensor", TORCH_FN(wrapper_Meta_Tensor_masked_fill_)); } } // anonymous namespace namespace meta { at::Tensor & masked_fill_(at::Tensor & self, const at::Tensor & mask, const at::Tensor & value) { return wrapper_Meta_Tensor_masked_fill_(self, mask, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__masked_scatter_(at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("masked_scatter_", TORCH_FN(wrapper_Meta__masked_scatter_)); } } // anonymous namespace namespace meta { at::Tensor & masked_scatter_(at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) { return wrapper_Meta__masked_scatter_(self, mask, source); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__view(const at::Tensor & self, c10::SymIntArrayRef size) { // No device check // DeviceGuard omitted return at::native::view(self, C10_AS_INTARRAYREF_SLOW(size)); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("view", TORCH_FN(wrapper_Meta__view)); } } // anonymous namespace namespace meta { at::Tensor view(const at::Tensor & self, at::IntArrayRef size) { return wrapper_Meta__view(self, c10::fromIntArrayRefSlow(size)); } at::Tensor view_symint(const at::Tensor & self, c10::SymIntArrayRef size) { return wrapper_Meta__view(self, size); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__put_(at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("put_", TORCH_FN(wrapper_Meta__put_)); } } // anonymous namespace namespace meta { at::Tensor & put_(at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate) { return wrapper_Meta__put_(self, index, source, accumulate); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_index_add_meta_functional final : public at::meta::structured_index_add { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_index_add(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha) { structured_index_add_meta_functional op; auto precompute = op.meta(self, dim, index, source, alpha); (void)precompute; return std::move(op.outputs_[0]); } struct structured_index_add_meta_out final : public at::meta::structured_index_add { structured_index_add_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_add_out_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha, at::Tensor & out) { structured_index_add_meta_out op(out); auto precompute = op.meta(self, dim, index, source, alpha); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_index_add_meta_inplace final : public at::meta::structured_index_add { structured_index_add_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_add_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha) { structured_index_add_meta_inplace op(self); auto precompute = op.meta(self, dim, index, source, alpha); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index_add", TORCH_FN(wrapper_Meta_index_add)); m.impl("index_add.out", TORCH_FN(wrapper_Meta_index_add_out_out)); m.impl("index_add_", TORCH_FN(wrapper_Meta_index_add_)); } } // anonymous namespace namespace meta { at::Tensor index_add(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha) { return wrapper_Meta_index_add(self, dim, index, source, alpha); } at::Tensor & index_add_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha) { return wrapper_Meta_index_add_out_out(self, dim, index, source, alpha, out); } at::Tensor & index_add_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha, at::Tensor & out) { return wrapper_Meta_index_add_out_out(self, dim, index, source, alpha, out); } at::Tensor & index_add_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, const at::Scalar & alpha) { return wrapper_Meta_index_add_(self, dim, index, source, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_index_reduce_meta_functional final : public at::meta::structured_index_reduce { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_index_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self) { structured_index_reduce_meta_functional op; auto precompute = op.meta(self, dim, index, source, reduce, include_self); (void)precompute; return std::move(op.outputs_[0]); } struct structured_index_reduce_meta_out final : public at::meta::structured_index_reduce { structured_index_reduce_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_reduce_out_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self, at::Tensor & out) { structured_index_reduce_meta_out op(out); auto precompute = op.meta(self, dim, index, source, reduce, include_self); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_index_reduce_meta_inplace final : public at::meta::structured_index_reduce { structured_index_reduce_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_index_reduce_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self) { structured_index_reduce_meta_inplace op(self); auto precompute = op.meta(self, dim, index, source, reduce, include_self); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index_reduce", TORCH_FN(wrapper_Meta_index_reduce)); m.impl("index_reduce.out", TORCH_FN(wrapper_Meta_index_reduce_out_out)); m.impl("index_reduce_", TORCH_FN(wrapper_Meta_index_reduce_)); } } // anonymous namespace namespace meta { at::Tensor index_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self) { return wrapper_Meta_index_reduce(self, dim, index, source, reduce, include_self); } at::Tensor & index_reduce_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self) { return wrapper_Meta_index_reduce_out_out(self, dim, index, source, reduce, include_self, out); } at::Tensor & index_reduce_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self, at::Tensor & out) { return wrapper_Meta_index_reduce_out_out(self, dim, index, source, reduce, include_self, out); } at::Tensor & index_reduce_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & source, c10::string_view reduce, bool include_self) { return wrapper_Meta_index_reduce_(self, dim, index, source, reduce, include_self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_int_Scalar_index_fill_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index_fill_.int_Scalar", TORCH_FN(wrapper_Meta_int_Scalar_index_fill_)); } } // anonymous namespace namespace meta { at::Tensor & index_fill_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { return wrapper_Meta_int_Scalar_index_fill_(self, dim, index, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_int_Tensor_index_fill_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("index_fill_.int_Tensor", TORCH_FN(wrapper_Meta_int_Tensor_index_fill_)); } } // anonymous namespace namespace meta { at::Tensor & index_fill_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value) { return wrapper_Meta_int_Tensor_index_fill_(self, dim, index, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_src_meta_functional final : public at::meta::structured_scatter_src { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_src(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { structured_scatter_src_meta_functional op; op.meta(self, dim, index, src); return std::move(op.outputs_[0]); } struct structured_scatter_src_meta_out final : public at::meta::structured_scatter_src { structured_scatter_src_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_out_src_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, at::Tensor & out) { structured_scatter_src_meta_out op(out); op.meta(self, dim, index, src); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_src_meta_inplace final : public at::meta::structured_scatter_src { structured_scatter_src_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter__src(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { structured_scatter_src_meta_inplace op(self); op.meta(self, dim, index, src); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter.src", TORCH_FN(wrapper_Meta_scatter_src)); m.impl("scatter.src_out", TORCH_FN(wrapper_Meta_scatter_out_src_out)); m.impl("scatter_.src", TORCH_FN(wrapper_Meta_scatter__src)); } } // anonymous namespace namespace meta { at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter_src(self, dim, index, src); } at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter_out_src_out(self, dim, index, src, out); } at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, at::Tensor & out) { return wrapper_Meta_scatter_out_src_out(self, dim, index, src, out); } at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter__src(self, dim, index, src); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_value_meta_functional final : public at::meta::structured_scatter_value { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_value(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { structured_scatter_value_meta_functional op; op.meta(self, dim, index, value); return std::move(op.outputs_[0]); } struct structured_scatter_value_meta_out final : public at::meta::structured_scatter_value { structured_scatter_value_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_out_value_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, at::Tensor & out) { structured_scatter_value_meta_out op(out); op.meta(self, dim, index, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_value_meta_inplace final : public at::meta::structured_scatter_value { structured_scatter_value_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter__value(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { structured_scatter_value_meta_inplace op(self); op.meta(self, dim, index, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter.value", TORCH_FN(wrapper_Meta_scatter_value)); m.impl("scatter.value_out", TORCH_FN(wrapper_Meta_scatter_out_value_out)); m.impl("scatter_.value", TORCH_FN(wrapper_Meta_scatter__value)); } } // anonymous namespace namespace meta { at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { return wrapper_Meta_scatter_value(self, dim, index, value); } at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { return wrapper_Meta_scatter_out_value_out(self, dim, index, value, out); } at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, at::Tensor & out) { return wrapper_Meta_scatter_out_value_out(self, dim, index, value, out); } at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) { return wrapper_Meta_scatter__value(self, dim, index, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_reduce_meta_functional final : public at::meta::structured_scatter_reduce { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce) { structured_scatter_reduce_meta_functional op; op.meta(self, dim, index, src, reduce); return std::move(op.outputs_[0]); } struct structured_scatter_reduce_meta_out final : public at::meta::structured_scatter_reduce { structured_scatter_reduce_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_out_reduce_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, at::Tensor & out) { structured_scatter_reduce_meta_out op(out); op.meta(self, dim, index, src, reduce); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_reduce_meta_inplace final : public at::meta::structured_scatter_reduce { structured_scatter_reduce_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter__reduce(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce) { structured_scatter_reduce_meta_inplace op(self); op.meta(self, dim, index, src, reduce); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter.reduce", TORCH_FN(wrapper_Meta_scatter_reduce)); m.impl("scatter.reduce_out", TORCH_FN(wrapper_Meta_scatter_out_reduce_out)); m.impl("scatter_.reduce", TORCH_FN(wrapper_Meta_scatter__reduce)); } } // anonymous namespace namespace meta { at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce) { return wrapper_Meta_scatter_reduce(self, dim, index, src, reduce); } at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce) { return wrapper_Meta_scatter_out_reduce_out(self, dim, index, src, reduce, out); } at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, at::Tensor & out) { return wrapper_Meta_scatter_out_reduce_out(self, dim, index, src, reduce, out); } at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce) { return wrapper_Meta_scatter__reduce(self, dim, index, src, reduce); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_value_reduce_meta_functional final : public at::meta::structured_scatter_value_reduce { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_value_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce) { structured_scatter_value_reduce_meta_functional op; op.meta(self, dim, index, value, reduce); return std::move(op.outputs_[0]); } struct structured_scatter_value_reduce_meta_out final : public at::meta::structured_scatter_value_reduce { structured_scatter_value_reduce_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_out_value_reduce_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce, at::Tensor & out) { structured_scatter_value_reduce_meta_out op(out); op.meta(self, dim, index, value, reduce); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_value_reduce_meta_inplace final : public at::meta::structured_scatter_value_reduce { structured_scatter_value_reduce_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter__value_reduce(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce) { structured_scatter_value_reduce_meta_inplace op(self); op.meta(self, dim, index, value, reduce); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter.value_reduce", TORCH_FN(wrapper_Meta_scatter_value_reduce)); m.impl("scatter.value_reduce_out", TORCH_FN(wrapper_Meta_scatter_out_value_reduce_out)); m.impl("scatter_.value_reduce", TORCH_FN(wrapper_Meta_scatter__value_reduce)); } } // anonymous namespace namespace meta { at::Tensor scatter(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce) { return wrapper_Meta_scatter_value_reduce(self, dim, index, value, reduce); } at::Tensor & scatter_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce) { return wrapper_Meta_scatter_out_value_reduce_out(self, dim, index, value, reduce, out); } at::Tensor & scatter_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce, at::Tensor & out) { return wrapper_Meta_scatter_out_value_reduce_out(self, dim, index, value, reduce, out); } at::Tensor & scatter_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, c10::string_view reduce) { return wrapper_Meta_scatter__value_reduce(self, dim, index, value, reduce); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_add_meta_functional final : public at::meta::structured_scatter_add { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_add(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { structured_scatter_add_meta_functional op; op.meta(self, dim, index, src); return std::move(op.outputs_[0]); } struct structured_scatter_add_meta_out final : public at::meta::structured_scatter_add { structured_scatter_add_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_add_out_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, at::Tensor & out) { structured_scatter_add_meta_out op(out); op.meta(self, dim, index, src); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_add_meta_inplace final : public at::meta::structured_scatter_add { structured_scatter_add_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_add_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { structured_scatter_add_meta_inplace op(self); op.meta(self, dim, index, src); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter_add", TORCH_FN(wrapper_Meta_scatter_add)); m.impl("scatter_add.out", TORCH_FN(wrapper_Meta_scatter_add_out_out)); m.impl("scatter_add_", TORCH_FN(wrapper_Meta_scatter_add_)); } } // anonymous namespace namespace meta { at::Tensor scatter_add(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter_add(self, dim, index, src); } at::Tensor & scatter_add_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter_add_out_out(self, dim, index, src, out); } at::Tensor & scatter_add_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, at::Tensor & out) { return wrapper_Meta_scatter_add_out_out(self, dim, index, src, out); } at::Tensor & scatter_add_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src) { return wrapper_Meta_scatter_add_(self, dim, index, src); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_scatter_reduce_two_meta_functional final : public at::meta::structured_scatter_reduce_two { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_scatter_reduce_two(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self) { structured_scatter_reduce_two_meta_functional op; op.meta(self, dim, index, src, reduce, include_self); return std::move(op.outputs_[0]); } struct structured_scatter_reduce_two_meta_out final : public at::meta::structured_scatter_reduce_two { structured_scatter_reduce_two_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_reduce_out_two_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self, at::Tensor & out) { structured_scatter_reduce_two_meta_out op(out); op.meta(self, dim, index, src, reduce, include_self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_scatter_reduce_two_meta_inplace final : public at::meta::structured_scatter_reduce_two { structured_scatter_reduce_two_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_scatter_reduce__two(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self) { structured_scatter_reduce_two_meta_inplace op(self); op.meta(self, dim, index, src, reduce, include_self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("scatter_reduce.two", TORCH_FN(wrapper_Meta_scatter_reduce_two)); m.impl("scatter_reduce.two_out", TORCH_FN(wrapper_Meta_scatter_reduce_out_two_out)); m.impl("scatter_reduce_.two", TORCH_FN(wrapper_Meta_scatter_reduce__two)); } } // anonymous namespace namespace meta { at::Tensor scatter_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self) { return wrapper_Meta_scatter_reduce_two(self, dim, index, src, reduce, include_self); } at::Tensor & scatter_reduce_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self) { return wrapper_Meta_scatter_reduce_out_two_out(self, dim, index, src, reduce, include_self, out); } at::Tensor & scatter_reduce_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self, at::Tensor & out) { return wrapper_Meta_scatter_reduce_out_two_out(self, dim, index, src, reduce, include_self, out); } at::Tensor & scatter_reduce_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self) { return wrapper_Meta_scatter_reduce__two(self, dim, index, src, reduce, include_self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_eq_Scalar_meta_functional final : public at::meta::structured_eq_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_eq_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_eq_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_eq_Scalar_meta_out final : public at::meta::structured_eq_Scalar { structured_eq_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_eq_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_eq_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_eq_Scalar_meta_inplace final : public at::meta::structured_eq_Scalar { structured_eq_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_eq__Scalar(at::Tensor & self, const at::Scalar & other) { structured_eq_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("eq.Scalar", TORCH_FN(wrapper_Meta_eq_Scalar)); m.impl("eq.Scalar_out", TORCH_FN(wrapper_Meta_eq_out_Scalar_out)); m.impl("eq_.Scalar", TORCH_FN(wrapper_Meta_eq__Scalar)); } } // anonymous namespace namespace meta { at::Tensor eq(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_eq_Scalar(self, other); } at::Tensor & eq_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_eq_out_Scalar_out(self, other, out); } at::Tensor & eq_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_eq_out_Scalar_out(self, other, out); } at::Tensor & eq_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_eq__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_eq_Tensor_meta_functional final : public at::meta::structured_eq_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_eq_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_eq_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_eq_Tensor_meta_out final : public at::meta::structured_eq_Tensor { structured_eq_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_eq_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_eq_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_eq_Tensor_meta_inplace final : public at::meta::structured_eq_Tensor { structured_eq_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_eq_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_eq__Tensor(at::Tensor & self, const at::Tensor & other) { structured_eq_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("eq.Tensor", TORCH_FN(wrapper_Meta_eq_Tensor)); m.impl("eq.Tensor_out", TORCH_FN(wrapper_Meta_eq_out_Tensor_out)); m.impl("eq_.Tensor", TORCH_FN(wrapper_Meta_eq__Tensor)); } } // anonymous namespace namespace meta { at::Tensor eq(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_eq_Tensor(self, other); } at::Tensor & eq_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_eq_out_Tensor_out(self, other, out); } at::Tensor & eq_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_eq_out_Tensor_out(self, other, out); } at::Tensor & eq_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_eq__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_and_Tensor_meta_functional final : public at::meta::structured_bitwise_and_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_and_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_bitwise_and_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_bitwise_and_Tensor_meta_out final : public at::meta::structured_bitwise_and_Tensor { structured_bitwise_and_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_and_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_bitwise_and_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_and_Tensor_meta_inplace final : public at::meta::structured_bitwise_and_Tensor { structured_bitwise_and_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_and_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_and__Tensor(at::Tensor & self, const at::Tensor & other) { structured_bitwise_and_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_and.Tensor", TORCH_FN(wrapper_Meta_bitwise_and_Tensor)); m.impl("bitwise_and.Tensor_out", TORCH_FN(wrapper_Meta_bitwise_and_out_Tensor_out)); m.impl("bitwise_and_.Tensor", TORCH_FN(wrapper_Meta_bitwise_and__Tensor)); } } // anonymous namespace namespace meta { at::Tensor bitwise_and(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_and_Tensor(self, other); } at::Tensor & bitwise_and_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_and_out_Tensor_out(self, other, out); } at::Tensor & bitwise_and_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_bitwise_and_out_Tensor_out(self, other, out); } at::Tensor & bitwise_and_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_and__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_or_Tensor_meta_functional final : public at::meta::structured_bitwise_or_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_or_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_bitwise_or_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_bitwise_or_Tensor_meta_out final : public at::meta::structured_bitwise_or_Tensor { structured_bitwise_or_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_or_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_bitwise_or_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_or_Tensor_meta_inplace final : public at::meta::structured_bitwise_or_Tensor { structured_bitwise_or_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_or_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_or__Tensor(at::Tensor & self, const at::Tensor & other) { structured_bitwise_or_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_or.Tensor", TORCH_FN(wrapper_Meta_bitwise_or_Tensor)); m.impl("bitwise_or.Tensor_out", TORCH_FN(wrapper_Meta_bitwise_or_out_Tensor_out)); m.impl("bitwise_or_.Tensor", TORCH_FN(wrapper_Meta_bitwise_or__Tensor)); } } // anonymous namespace namespace meta { at::Tensor bitwise_or(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_or_Tensor(self, other); } at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_or_out_Tensor_out(self, other, out); } at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_bitwise_or_out_Tensor_out(self, other, out); } at::Tensor & bitwise_or_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_or__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_xor_Tensor_meta_functional final : public at::meta::structured_bitwise_xor_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_xor_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_bitwise_xor_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_bitwise_xor_Tensor_meta_out final : public at::meta::structured_bitwise_xor_Tensor { structured_bitwise_xor_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_xor_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_bitwise_xor_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_xor_Tensor_meta_inplace final : public at::meta::structured_bitwise_xor_Tensor { structured_bitwise_xor_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_xor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_xor__Tensor(at::Tensor & self, const at::Tensor & other) { structured_bitwise_xor_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_xor.Tensor", TORCH_FN(wrapper_Meta_bitwise_xor_Tensor)); m.impl("bitwise_xor.Tensor_out", TORCH_FN(wrapper_Meta_bitwise_xor_out_Tensor_out)); m.impl("bitwise_xor_.Tensor", TORCH_FN(wrapper_Meta_bitwise_xor__Tensor)); } } // anonymous namespace namespace meta { at::Tensor bitwise_xor(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_xor_Tensor(self, other); } at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_xor_out_Tensor_out(self, other, out); } at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_bitwise_xor_out_Tensor_out(self, other, out); } at::Tensor & bitwise_xor_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_xor__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Scalar___ilshift__(at::Tensor & self, const at::Scalar & other) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("__ilshift__.Scalar", TORCH_FN(wrapper_Meta_Scalar___ilshift__)); } } // anonymous namespace namespace meta { at::Tensor & __ilshift__(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_Scalar___ilshift__(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor___ilshift__(at::Tensor & self, const at::Tensor & other) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("__ilshift__.Tensor", TORCH_FN(wrapper_Meta_Tensor___ilshift__)); } } // anonymous namespace namespace meta { at::Tensor & __ilshift__(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_Tensor___ilshift__(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_left_shift_Tensor_meta_functional final : public at::meta::structured_bitwise_left_shift_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_left_shift_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_bitwise_left_shift_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_bitwise_left_shift_Tensor_meta_out final : public at::meta::structured_bitwise_left_shift_Tensor { structured_bitwise_left_shift_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_left_shift_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_bitwise_left_shift_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_left_shift_Tensor_meta_inplace final : public at::meta::structured_bitwise_left_shift_Tensor { structured_bitwise_left_shift_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_left_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_left_shift__Tensor(at::Tensor & self, const at::Tensor & other) { structured_bitwise_left_shift_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_left_shift.Tensor", TORCH_FN(wrapper_Meta_bitwise_left_shift_Tensor)); m.impl("bitwise_left_shift.Tensor_out", TORCH_FN(wrapper_Meta_bitwise_left_shift_out_Tensor_out)); m.impl("bitwise_left_shift_.Tensor", TORCH_FN(wrapper_Meta_bitwise_left_shift__Tensor)); } } // anonymous namespace namespace meta { at::Tensor bitwise_left_shift(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_left_shift_Tensor(self, other); } at::Tensor & bitwise_left_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_left_shift_out_Tensor_out(self, other, out); } at::Tensor & bitwise_left_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_bitwise_left_shift_out_Tensor_out(self, other, out); } at::Tensor & bitwise_left_shift_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_left_shift__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Scalar___irshift__(at::Tensor & self, const at::Scalar & other) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("__irshift__.Scalar", TORCH_FN(wrapper_Meta_Scalar___irshift__)); } } // anonymous namespace namespace meta { at::Tensor & __irshift__(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_Scalar___irshift__(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta_Tensor___irshift__(at::Tensor & self, const at::Tensor & other) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("__irshift__.Tensor", TORCH_FN(wrapper_Meta_Tensor___irshift__)); } } // anonymous namespace namespace meta { at::Tensor & __irshift__(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_Tensor___irshift__(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_bitwise_right_shift_Tensor_meta_functional final : public at::meta::structured_bitwise_right_shift_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_bitwise_right_shift_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_bitwise_right_shift_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_bitwise_right_shift_Tensor_meta_out final : public at::meta::structured_bitwise_right_shift_Tensor { structured_bitwise_right_shift_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_right_shift_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_bitwise_right_shift_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_bitwise_right_shift_Tensor_meta_inplace final : public at::meta::structured_bitwise_right_shift_Tensor { structured_bitwise_right_shift_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_bitwise_right_shift_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_bitwise_right_shift__Tensor(at::Tensor & self, const at::Tensor & other) { structured_bitwise_right_shift_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("bitwise_right_shift.Tensor", TORCH_FN(wrapper_Meta_bitwise_right_shift_Tensor)); m.impl("bitwise_right_shift.Tensor_out", TORCH_FN(wrapper_Meta_bitwise_right_shift_out_Tensor_out)); m.impl("bitwise_right_shift_.Tensor", TORCH_FN(wrapper_Meta_bitwise_right_shift__Tensor)); } } // anonymous namespace namespace meta { at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_right_shift_Tensor(self, other); } at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_right_shift_out_Tensor_out(self, other, out); } at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_bitwise_right_shift_out_Tensor_out(self, other, out); } at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_bitwise_right_shift__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_tril_meta_functional final : public at::meta::structured_tril { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_tril(const at::Tensor & self, int64_t diagonal) { structured_tril_meta_functional op; op.meta(self, diagonal); return std::move(op.outputs_[0]); } struct structured_tril_meta_out final : public at::meta::structured_tril { structured_tril_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tril_out_out(const at::Tensor & self, int64_t diagonal, at::Tensor & out) { structured_tril_meta_out op(out); op.meta(self, diagonal); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_tril_meta_inplace final : public at::meta::structured_tril { structured_tril_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tril_(at::Tensor & self, int64_t diagonal) { structured_tril_meta_inplace op(self); op.meta(self, diagonal); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("tril", TORCH_FN(wrapper_Meta_tril)); m.impl("tril.out", TORCH_FN(wrapper_Meta_tril_out_out)); m.impl("tril_", TORCH_FN(wrapper_Meta_tril_)); } } // anonymous namespace namespace meta { at::Tensor tril(const at::Tensor & self, int64_t diagonal) { return wrapper_Meta_tril(self, diagonal); } at::Tensor & tril_out(at::Tensor & out, const at::Tensor & self, int64_t diagonal) { return wrapper_Meta_tril_out_out(self, diagonal, out); } at::Tensor & tril_outf(const at::Tensor & self, int64_t diagonal, at::Tensor & out) { return wrapper_Meta_tril_out_out(self, diagonal, out); } at::Tensor & tril_(at::Tensor & self, int64_t diagonal) { return wrapper_Meta_tril_(self, diagonal); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_triu_meta_functional final : public at::meta::structured_triu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_triu(const at::Tensor & self, int64_t diagonal) { structured_triu_meta_functional op; op.meta(self, diagonal); return std::move(op.outputs_[0]); } struct structured_triu_meta_out final : public at::meta::structured_triu { structured_triu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_triu_out_out(const at::Tensor & self, int64_t diagonal, at::Tensor & out) { structured_triu_meta_out op(out); op.meta(self, diagonal); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_triu_meta_inplace final : public at::meta::structured_triu { structured_triu_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_triu_(at::Tensor & self, int64_t diagonal) { structured_triu_meta_inplace op(self); op.meta(self, diagonal); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("triu", TORCH_FN(wrapper_Meta_triu)); m.impl("triu.out", TORCH_FN(wrapper_Meta_triu_out_out)); m.impl("triu_", TORCH_FN(wrapper_Meta_triu_)); } } // anonymous namespace namespace meta { at::Tensor triu(const at::Tensor & self, int64_t diagonal) { return wrapper_Meta_triu(self, diagonal); } at::Tensor & triu_out(at::Tensor & out, const at::Tensor & self, int64_t diagonal) { return wrapper_Meta_triu_out_out(self, diagonal, out); } at::Tensor & triu_outf(const at::Tensor & self, int64_t diagonal, at::Tensor & out) { return wrapper_Meta_triu_out_out(self, diagonal, out); } at::Tensor & triu_(at::Tensor & self, int64_t diagonal) { return wrapper_Meta_triu_(self, diagonal); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_digamma_meta_functional final : public at::meta::structured_digamma { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_digamma(const at::Tensor & self) { structured_digamma_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_digamma_meta_out final : public at::meta::structured_digamma { structured_digamma_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_digamma_out_out(const at::Tensor & self, at::Tensor & out) { structured_digamma_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_digamma_meta_inplace final : public at::meta::structured_digamma { structured_digamma_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_digamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_digamma_(at::Tensor & self) { structured_digamma_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("digamma", TORCH_FN(wrapper_Meta_digamma)); m.impl("digamma.out", TORCH_FN(wrapper_Meta_digamma_out_out)); m.impl("digamma_", TORCH_FN(wrapper_Meta_digamma_)); } } // anonymous namespace namespace meta { at::Tensor digamma(const at::Tensor & self) { return wrapper_Meta_digamma(self); } at::Tensor & digamma_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_digamma_out_out(self, out); } at::Tensor & digamma_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_digamma_out_out(self, out); } at::Tensor & digamma_(at::Tensor & self) { return wrapper_Meta_digamma_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lerp_Scalar_meta_functional final : public at::meta::structured_lerp_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lerp_Scalar(const at::Tensor & self, const at::Tensor & end, const at::Scalar & weight) { structured_lerp_Scalar_meta_functional op; op.meta(self, end, weight); return std::move(op.outputs_[0]); } struct structured_lerp_Scalar_meta_out final : public at::meta::structured_lerp_Scalar { structured_lerp_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lerp_out_Scalar_out(const at::Tensor & self, const at::Tensor & end, const at::Scalar & weight, at::Tensor & out) { structured_lerp_Scalar_meta_out op(out); op.meta(self, end, weight); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lerp_Scalar_meta_inplace final : public at::meta::structured_lerp_Scalar { structured_lerp_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lerp__Scalar(at::Tensor & self, const at::Tensor & end, const at::Scalar & weight) { structured_lerp_Scalar_meta_inplace op(self); op.meta(self, end, weight); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lerp.Scalar", TORCH_FN(wrapper_Meta_lerp_Scalar)); m.impl("lerp.Scalar_out", TORCH_FN(wrapper_Meta_lerp_out_Scalar_out)); m.impl("lerp_.Scalar", TORCH_FN(wrapper_Meta_lerp__Scalar)); } } // anonymous namespace namespace meta { at::Tensor lerp(const at::Tensor & self, const at::Tensor & end, const at::Scalar & weight) { return wrapper_Meta_lerp_Scalar(self, end, weight); } at::Tensor & lerp_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & end, const at::Scalar & weight) { return wrapper_Meta_lerp_out_Scalar_out(self, end, weight, out); } at::Tensor & lerp_outf(const at::Tensor & self, const at::Tensor & end, const at::Scalar & weight, at::Tensor & out) { return wrapper_Meta_lerp_out_Scalar_out(self, end, weight, out); } at::Tensor & lerp_(at::Tensor & self, const at::Tensor & end, const at::Scalar & weight) { return wrapper_Meta_lerp__Scalar(self, end, weight); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lerp_Tensor_meta_functional final : public at::meta::structured_lerp_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lerp_Tensor(const at::Tensor & self, const at::Tensor & end, const at::Tensor & weight) { structured_lerp_Tensor_meta_functional op; op.meta(self, end, weight); return std::move(op.outputs_[0]); } struct structured_lerp_Tensor_meta_out final : public at::meta::structured_lerp_Tensor { structured_lerp_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lerp_out_Tensor_out(const at::Tensor & self, const at::Tensor & end, const at::Tensor & weight, at::Tensor & out) { structured_lerp_Tensor_meta_out op(out); op.meta(self, end, weight); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lerp_Tensor_meta_inplace final : public at::meta::structured_lerp_Tensor { structured_lerp_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lerp_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lerp__Tensor(at::Tensor & self, const at::Tensor & end, const at::Tensor & weight) { structured_lerp_Tensor_meta_inplace op(self); op.meta(self, end, weight); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lerp.Tensor", TORCH_FN(wrapper_Meta_lerp_Tensor)); m.impl("lerp.Tensor_out", TORCH_FN(wrapper_Meta_lerp_out_Tensor_out)); m.impl("lerp_.Tensor", TORCH_FN(wrapper_Meta_lerp__Tensor)); } } // anonymous namespace namespace meta { at::Tensor lerp(const at::Tensor & self, const at::Tensor & end, const at::Tensor & weight) { return wrapper_Meta_lerp_Tensor(self, end, weight); } at::Tensor & lerp_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & end, const at::Tensor & weight) { return wrapper_Meta_lerp_out_Tensor_out(self, end, weight, out); } at::Tensor & lerp_outf(const at::Tensor & self, const at::Tensor & end, const at::Tensor & weight, at::Tensor & out) { return wrapper_Meta_lerp_out_Tensor_out(self, end, weight, out); } at::Tensor & lerp_(at::Tensor & self, const at::Tensor & end, const at::Tensor & weight) { return wrapper_Meta_lerp__Tensor(self, end, weight); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__addbmm_(at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("addbmm_", TORCH_FN(wrapper_Meta__addbmm_)); } } // anonymous namespace namespace meta { at::Tensor & addbmm_(at::Tensor & self, const at::Tensor & batch1, const at::Tensor & batch2, const at::Scalar & beta, const at::Scalar & alpha) { return wrapper_Meta__addbmm_(self, batch1, batch2, beta, alpha); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_from_random_(at::Tensor & self, int64_t from, ::std::optional to, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::random_meta_(self, from, to, generator); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("random_.from", TORCH_FN(wrapper_Meta_from_random_)); } } // anonymous namespace namespace meta { at::Tensor & random_(at::Tensor & self, int64_t from, ::std::optional to, ::std::optional generator) { return wrapper_Meta_from_random_(self, from, to, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta_to_random_(at::Tensor & self, int64_t to, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::random_meta_(self, to, generator); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("random_.to", TORCH_FN(wrapper_Meta_to_random_)); } } // anonymous namespace namespace meta { at::Tensor & random_(at::Tensor & self, int64_t to, ::std::optional generator) { return wrapper_Meta_to_random_(self, to, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta__random_(at::Tensor & self, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::random_meta_(self, generator); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("random_", TORCH_FN(wrapper_Meta__random_)); } } // anonymous namespace namespace meta { at::Tensor & random_(at::Tensor & self, ::std::optional generator) { return wrapper_Meta__random_(self, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta__uniform_(at::Tensor & self, double from, double to, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::uniform_meta_(self, from, to, generator); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("uniform_", TORCH_FN(wrapper_Meta__uniform_)); } } // anonymous namespace namespace meta { at::Tensor & uniform_(at::Tensor & self, double from, double to, ::std::optional generator) { return wrapper_Meta__uniform_(self, from, to, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__cauchy_(at::Tensor & self, double median, double sigma, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("cauchy_", TORCH_FN(wrapper_Meta__cauchy_)); } } // anonymous namespace namespace meta { at::Tensor & cauchy_(at::Tensor & self, double median, double sigma, ::std::optional generator) { return wrapper_Meta__cauchy_(self, median, sigma, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__log_normal_(at::Tensor & self, double mean, double std, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("log_normal_", TORCH_FN(wrapper_Meta__log_normal_)); } } // anonymous namespace namespace meta { at::Tensor & log_normal_(at::Tensor & self, double mean, double std, ::std::optional generator) { return wrapper_Meta__log_normal_(self, mean, std, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__exponential_(at::Tensor & self, double lambd, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("exponential_", TORCH_FN(wrapper_Meta__exponential_)); } } // anonymous namespace namespace meta { at::Tensor & exponential_(at::Tensor & self, double lambd, ::std::optional generator) { return wrapper_Meta__exponential_(self, lambd, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__geometric_(at::Tensor & self, double p, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("geometric_", TORCH_FN(wrapper_Meta__geometric_)); } } // anonymous namespace namespace meta { at::Tensor & geometric_(at::Tensor & self, double p, ::std::optional generator) { return wrapper_Meta__geometric_(self, p, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_ne_Scalar_meta_functional final : public at::meta::structured_ne_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_ne_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_ne_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_ne_Scalar_meta_out final : public at::meta::structured_ne_Scalar { structured_ne_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ne_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_ne_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_ne_Scalar_meta_inplace final : public at::meta::structured_ne_Scalar { structured_ne_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ne__Scalar(at::Tensor & self, const at::Scalar & other) { structured_ne_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("ne.Scalar", TORCH_FN(wrapper_Meta_ne_Scalar)); m.impl("ne.Scalar_out", TORCH_FN(wrapper_Meta_ne_out_Scalar_out)); m.impl("ne_.Scalar", TORCH_FN(wrapper_Meta_ne__Scalar)); } } // anonymous namespace namespace meta { at::Tensor ne(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ne_Scalar(self, other); } at::Tensor & ne_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ne_out_Scalar_out(self, other, out); } at::Tensor & ne_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_ne_out_Scalar_out(self, other, out); } at::Tensor & ne_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ne__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_ne_Tensor_meta_functional final : public at::meta::structured_ne_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_ne_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_ne_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_ne_Tensor_meta_out final : public at::meta::structured_ne_Tensor { structured_ne_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ne_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_ne_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_ne_Tensor_meta_inplace final : public at::meta::structured_ne_Tensor { structured_ne_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ne_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ne__Tensor(at::Tensor & self, const at::Tensor & other) { structured_ne_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("ne.Tensor", TORCH_FN(wrapper_Meta_ne_Tensor)); m.impl("ne.Tensor_out", TORCH_FN(wrapper_Meta_ne_out_Tensor_out)); m.impl("ne_.Tensor", TORCH_FN(wrapper_Meta_ne__Tensor)); } } // anonymous namespace namespace meta { at::Tensor ne(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ne_Tensor(self, other); } at::Tensor & ne_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ne_out_Tensor_out(self, other, out); } at::Tensor & ne_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_ne_out_Tensor_out(self, other, out); } at::Tensor & ne_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ne__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_ge_Scalar_meta_functional final : public at::meta::structured_ge_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_ge_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_ge_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_ge_Scalar_meta_out final : public at::meta::structured_ge_Scalar { structured_ge_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ge_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_ge_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_ge_Scalar_meta_inplace final : public at::meta::structured_ge_Scalar { structured_ge_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ge__Scalar(at::Tensor & self, const at::Scalar & other) { structured_ge_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("ge.Scalar", TORCH_FN(wrapper_Meta_ge_Scalar)); m.impl("ge.Scalar_out", TORCH_FN(wrapper_Meta_ge_out_Scalar_out)); m.impl("ge_.Scalar", TORCH_FN(wrapper_Meta_ge__Scalar)); } } // anonymous namespace namespace meta { at::Tensor ge(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ge_Scalar(self, other); } at::Tensor & ge_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ge_out_Scalar_out(self, other, out); } at::Tensor & ge_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_ge_out_Scalar_out(self, other, out); } at::Tensor & ge_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_ge__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_ge_Tensor_meta_functional final : public at::meta::structured_ge_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_ge_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_ge_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_ge_Tensor_meta_out final : public at::meta::structured_ge_Tensor { structured_ge_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ge_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_ge_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_ge_Tensor_meta_inplace final : public at::meta::structured_ge_Tensor { structured_ge_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_ge_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_ge__Tensor(at::Tensor & self, const at::Tensor & other) { structured_ge_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("ge.Tensor", TORCH_FN(wrapper_Meta_ge_Tensor)); m.impl("ge.Tensor_out", TORCH_FN(wrapper_Meta_ge_out_Tensor_out)); m.impl("ge_.Tensor", TORCH_FN(wrapper_Meta_ge__Tensor)); } } // anonymous namespace namespace meta { at::Tensor ge(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ge_Tensor(self, other); } at::Tensor & ge_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ge_out_Tensor_out(self, other, out); } at::Tensor & ge_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_ge_out_Tensor_out(self, other, out); } at::Tensor & ge_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_ge__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_le_Scalar_meta_functional final : public at::meta::structured_le_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_le_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_le_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_le_Scalar_meta_out final : public at::meta::structured_le_Scalar { structured_le_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_le_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_le_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_le_Scalar_meta_inplace final : public at::meta::structured_le_Scalar { structured_le_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_le__Scalar(at::Tensor & self, const at::Scalar & other) { structured_le_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("le.Scalar", TORCH_FN(wrapper_Meta_le_Scalar)); m.impl("le.Scalar_out", TORCH_FN(wrapper_Meta_le_out_Scalar_out)); m.impl("le_.Scalar", TORCH_FN(wrapper_Meta_le__Scalar)); } } // anonymous namespace namespace meta { at::Tensor le(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_le_Scalar(self, other); } at::Tensor & le_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_le_out_Scalar_out(self, other, out); } at::Tensor & le_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_le_out_Scalar_out(self, other, out); } at::Tensor & le_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_le__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_le_Tensor_meta_functional final : public at::meta::structured_le_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_le_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_le_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_le_Tensor_meta_out final : public at::meta::structured_le_Tensor { structured_le_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_le_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_le_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_le_Tensor_meta_inplace final : public at::meta::structured_le_Tensor { structured_le_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_le_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_le__Tensor(at::Tensor & self, const at::Tensor & other) { structured_le_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("le.Tensor", TORCH_FN(wrapper_Meta_le_Tensor)); m.impl("le.Tensor_out", TORCH_FN(wrapper_Meta_le_out_Tensor_out)); m.impl("le_.Tensor", TORCH_FN(wrapper_Meta_le__Tensor)); } } // anonymous namespace namespace meta { at::Tensor le(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_le_Tensor(self, other); } at::Tensor & le_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_le_out_Tensor_out(self, other, out); } at::Tensor & le_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_le_out_Tensor_out(self, other, out); } at::Tensor & le_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_le__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gt_Scalar_meta_functional final : public at::meta::structured_gt_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gt_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_gt_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_gt_Scalar_meta_out final : public at::meta::structured_gt_Scalar { structured_gt_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gt_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_gt_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_gt_Scalar_meta_inplace final : public at::meta::structured_gt_Scalar { structured_gt_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gt__Scalar(at::Tensor & self, const at::Scalar & other) { structured_gt_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gt.Scalar", TORCH_FN(wrapper_Meta_gt_Scalar)); m.impl("gt.Scalar_out", TORCH_FN(wrapper_Meta_gt_out_Scalar_out)); m.impl("gt_.Scalar", TORCH_FN(wrapper_Meta_gt__Scalar)); } } // anonymous namespace namespace meta { at::Tensor gt(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_gt_Scalar(self, other); } at::Tensor & gt_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_gt_out_Scalar_out(self, other, out); } at::Tensor & gt_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_gt_out_Scalar_out(self, other, out); } at::Tensor & gt_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_gt__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gt_Tensor_meta_functional final : public at::meta::structured_gt_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gt_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_gt_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_gt_Tensor_meta_out final : public at::meta::structured_gt_Tensor { structured_gt_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gt_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_gt_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_gt_Tensor_meta_inplace final : public at::meta::structured_gt_Tensor { structured_gt_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_gt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gt__Tensor(at::Tensor & self, const at::Tensor & other) { structured_gt_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gt.Tensor", TORCH_FN(wrapper_Meta_gt_Tensor)); m.impl("gt.Tensor_out", TORCH_FN(wrapper_Meta_gt_out_Tensor_out)); m.impl("gt_.Tensor", TORCH_FN(wrapper_Meta_gt__Tensor)); } } // anonymous namespace namespace meta { at::Tensor gt(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gt_Tensor(self, other); } at::Tensor & gt_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gt_out_Tensor_out(self, other, out); } at::Tensor & gt_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_gt_out_Tensor_out(self, other, out); } at::Tensor & gt_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_gt__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lt_Scalar_meta_functional final : public at::meta::structured_lt_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lt_Scalar(const at::Tensor & self, const at::Scalar & other) { structured_lt_Scalar_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_lt_Scalar_meta_out final : public at::meta::structured_lt_Scalar { structured_lt_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lt_out_Scalar_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { structured_lt_Scalar_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lt_Scalar_meta_inplace final : public at::meta::structured_lt_Scalar { structured_lt_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lt__Scalar(at::Tensor & self, const at::Scalar & other) { structured_lt_Scalar_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lt.Scalar", TORCH_FN(wrapper_Meta_lt_Scalar)); m.impl("lt.Scalar_out", TORCH_FN(wrapper_Meta_lt_out_Scalar_out)); m.impl("lt_.Scalar", TORCH_FN(wrapper_Meta_lt__Scalar)); } } // anonymous namespace namespace meta { at::Tensor lt(const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_lt_Scalar(self, other); } at::Tensor & lt_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_lt_out_Scalar_out(self, other, out); } at::Tensor & lt_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { return wrapper_Meta_lt_out_Scalar_out(self, other, out); } at::Tensor & lt_(at::Tensor & self, const at::Scalar & other) { return wrapper_Meta_lt__Scalar(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lt_Tensor_meta_functional final : public at::meta::structured_lt_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lt_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_lt_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_lt_Tensor_meta_out final : public at::meta::structured_lt_Tensor { structured_lt_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lt_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_lt_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lt_Tensor_meta_inplace final : public at::meta::structured_lt_Tensor { structured_lt_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lt_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lt__Tensor(at::Tensor & self, const at::Tensor & other) { structured_lt_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lt.Tensor", TORCH_FN(wrapper_Meta_lt_Tensor)); m.impl("lt.Tensor_out", TORCH_FN(wrapper_Meta_lt_out_Tensor_out)); m.impl("lt_.Tensor", TORCH_FN(wrapper_Meta_lt__Tensor)); } } // anonymous namespace namespace meta { at::Tensor lt(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lt_Tensor(self, other); } at::Tensor & lt_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lt_out_Tensor_out(self, other, out); } at::Tensor & lt_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_lt_out_Tensor_out(self, other, out); } at::Tensor & lt_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_lt__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_gather_meta_functional final : public at::meta::structured_gather { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_gather(const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad) { structured_gather_meta_functional op; op.meta(self, dim, index, sparse_grad); return std::move(op.outputs_[0]); } struct structured_gather_meta_out final : public at::meta::structured_gather { structured_gather_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_gather_out_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad, at::Tensor & out) { structured_gather_meta_out op(out); op.meta(self, dim, index, sparse_grad); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("gather", TORCH_FN(wrapper_Meta_gather)); m.impl("gather.out", TORCH_FN(wrapper_Meta_gather_out_out)); } } // anonymous namespace namespace meta { at::Tensor gather(const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad) { return wrapper_Meta_gather(self, dim, index, sparse_grad); } at::Tensor & gather_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad) { return wrapper_Meta_gather_out_out(self, dim, index, sparse_grad, out); } at::Tensor & gather_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad, at::Tensor & out) { return wrapper_Meta_gather_out_out(self, dim, index, sparse_grad, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_addcmul_meta_functional final : public at::meta::structured_addcmul { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_addcmul(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { structured_addcmul_meta_functional op; op.meta(self, tensor1, tensor2, value); return std::move(op.outputs_[0]); } struct structured_addcmul_meta_out final : public at::meta::structured_addcmul { structured_addcmul_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addcmul_out_out(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value, at::Tensor & out) { structured_addcmul_meta_out op(out); op.meta(self, tensor1, tensor2, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_addcmul_meta_inplace final : public at::meta::structured_addcmul { structured_addcmul_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcmul::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addcmul_(at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { structured_addcmul_meta_inplace op(self); op.meta(self, tensor1, tensor2, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("addcmul", TORCH_FN(wrapper_Meta_addcmul)); m.impl("addcmul.out", TORCH_FN(wrapper_Meta_addcmul_out_out)); m.impl("addcmul_", TORCH_FN(wrapper_Meta_addcmul_)); } } // anonymous namespace namespace meta { at::Tensor addcmul(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcmul(self, tensor1, tensor2, value); } at::Tensor & addcmul_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcmul_out_out(self, tensor1, tensor2, value, out); } at::Tensor & addcmul_outf(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value, at::Tensor & out) { return wrapper_Meta_addcmul_out_out(self, tensor1, tensor2, value, out); } at::Tensor & addcmul_(at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcmul_(self, tensor1, tensor2, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_addcdiv_meta_functional final : public at::meta::structured_addcdiv { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_addcdiv(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { structured_addcdiv_meta_functional op; op.meta(self, tensor1, tensor2, value); return std::move(op.outputs_[0]); } struct structured_addcdiv_meta_out final : public at::meta::structured_addcdiv { structured_addcdiv_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addcdiv_out_out(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value, at::Tensor & out) { structured_addcdiv_meta_out op(out); op.meta(self, tensor1, tensor2, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_addcdiv_meta_inplace final : public at::meta::structured_addcdiv { structured_addcdiv_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_addcdiv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_addcdiv_(at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { structured_addcdiv_meta_inplace op(self); op.meta(self, tensor1, tensor2, value); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("addcdiv", TORCH_FN(wrapper_Meta_addcdiv)); m.impl("addcdiv.out", TORCH_FN(wrapper_Meta_addcdiv_out_out)); m.impl("addcdiv_", TORCH_FN(wrapper_Meta_addcdiv_)); } } // anonymous namespace namespace meta { at::Tensor addcdiv(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcdiv(self, tensor1, tensor2, value); } at::Tensor & addcdiv_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcdiv_out_out(self, tensor1, tensor2, value, out); } at::Tensor & addcdiv_outf(const at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value, at::Tensor & out) { return wrapper_Meta_addcdiv_out_out(self, tensor1, tensor2, value, out); } at::Tensor & addcdiv_(at::Tensor & self, const at::Tensor & tensor1, const at::Tensor & tensor2, const at::Scalar & value) { return wrapper_Meta_addcdiv_(self, tensor1, tensor2, value); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_triangular_solve_meta_functional final : public at::meta::structured_triangular_solve { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_triangular_solve(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular) { structured_triangular_solve_meta_functional op; op.meta(self, A, upper, transpose, unitriangular); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_triangular_solve_meta_out final : public at::meta::structured_triangular_solve { structured_triangular_solve_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_triangular_solve_out_X(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular, at::Tensor & X, at::Tensor & M) { structured_triangular_solve_meta_out op(X, M); op.meta(self, A, upper, transpose, unitriangular); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(X, M); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("triangular_solve", TORCH_FN(wrapper_Meta_triangular_solve)); m.impl("triangular_solve.X", TORCH_FN(wrapper_Meta_triangular_solve_out_X)); } } // anonymous namespace namespace meta { ::std::tuple triangular_solve(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular) { return wrapper_Meta_triangular_solve(self, A, upper, transpose, unitriangular); } ::std::tuple triangular_solve_out(at::Tensor & X, at::Tensor & M, const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular) { return wrapper_Meta_triangular_solve_out_X(self, A, upper, transpose, unitriangular, X, M); } ::std::tuple triangular_solve_outf(const at::Tensor & self, const at::Tensor & A, bool upper, bool transpose, bool unitriangular, at::Tensor & X, at::Tensor & M) { return wrapper_Meta_triangular_solve_out_X(self, A, upper, transpose, unitriangular, X, M); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lu_unpack_meta_functional final : public at::meta::structured_lu_unpack { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_lu_unpack(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots) { structured_lu_unpack_meta_functional op; op.meta(LU_data, LU_pivots, unpack_data, unpack_pivots); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured_lu_unpack_meta_out final : public at::meta::structured_lu_unpack { structured_lu_unpack_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta_lu_unpack_out_out(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots, at::Tensor & P, at::Tensor & L, at::Tensor & U) { structured_lu_unpack_meta_out op(P, L, U); op.meta(LU_data, LU_pivots, unpack_data, unpack_pivots); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(P, L, U); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lu_unpack", TORCH_FN(wrapper_Meta_lu_unpack)); m.impl("lu_unpack.out", TORCH_FN(wrapper_Meta_lu_unpack_out_out)); } } // anonymous namespace namespace meta { ::std::tuple lu_unpack(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots) { return wrapper_Meta_lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots); } ::std::tuple lu_unpack_out(at::Tensor & P, at::Tensor & L, at::Tensor & U, const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots) { return wrapper_Meta_lu_unpack_out_out(LU_data, LU_pivots, unpack_data, unpack_pivots, P, L, U); } ::std::tuple lu_unpack_outf(const at::Tensor & LU_data, const at::Tensor & LU_pivots, bool unpack_data, bool unpack_pivots, at::Tensor & P, at::Tensor & L, at::Tensor & U) { return wrapper_Meta_lu_unpack_out_out(LU_data, LU_pivots, unpack_data, unpack_pivots, P, L, U); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_lgamma_meta_functional final : public at::meta::structured_lgamma { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_lgamma(const at::Tensor & self) { structured_lgamma_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_lgamma_meta_out final : public at::meta::structured_lgamma { structured_lgamma_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lgamma_out_out(const at::Tensor & self, at::Tensor & out) { structured_lgamma_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_lgamma_meta_inplace final : public at::meta::structured_lgamma { structured_lgamma_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_lgamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_lgamma_(at::Tensor & self) { structured_lgamma_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("lgamma", TORCH_FN(wrapper_Meta_lgamma)); m.impl("lgamma.out", TORCH_FN(wrapper_Meta_lgamma_out_out)); m.impl("lgamma_", TORCH_FN(wrapper_Meta_lgamma_)); } } // anonymous namespace namespace meta { at::Tensor lgamma(const at::Tensor & self) { return wrapper_Meta_lgamma(self); } at::Tensor & lgamma_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_lgamma_out_out(self, out); } at::Tensor & lgamma_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_lgamma_out_out(self, out); } at::Tensor & lgamma_(at::Tensor & self) { return wrapper_Meta_lgamma_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_polygamma_meta_functional final : public at::meta::structured_polygamma { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_polygamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_polygamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_polygamma(int64_t n, const at::Tensor & self) { structured_polygamma_meta_functional op; op.meta(n, self); return std::move(op.outputs_[0]); } struct structured_polygamma_meta_out final : public at::meta::structured_polygamma { structured_polygamma_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_polygamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_polygamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_polygamma_out_out(int64_t n, const at::Tensor & self, at::Tensor & out) { structured_polygamma_meta_out op(out); op.meta(n, self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("polygamma", TORCH_FN(wrapper_Meta_polygamma)); m.impl("polygamma.out", TORCH_FN(wrapper_Meta_polygamma_out_out)); } } // anonymous namespace namespace meta { at::Tensor polygamma(int64_t n, const at::Tensor & self) { return wrapper_Meta_polygamma(n, self); } at::Tensor & polygamma_out(at::Tensor & out, int64_t n, const at::Tensor & self) { return wrapper_Meta_polygamma_out_out(n, self, out); } at::Tensor & polygamma_outf(int64_t n, const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_polygamma_out_out(n, self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_erfinv_meta_functional final : public at::meta::structured_erfinv { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_erfinv(const at::Tensor & self) { structured_erfinv_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_erfinv_meta_out final : public at::meta::structured_erfinv { structured_erfinv_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erfinv_out_out(const at::Tensor & self, at::Tensor & out) { structured_erfinv_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_erfinv_meta_inplace final : public at::meta::structured_erfinv { structured_erfinv_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_erfinv::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_erfinv_(at::Tensor & self) { structured_erfinv_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("erfinv", TORCH_FN(wrapper_Meta_erfinv)); m.impl("erfinv.out", TORCH_FN(wrapper_Meta_erfinv_out_out)); m.impl("erfinv_", TORCH_FN(wrapper_Meta_erfinv_)); } } // anonymous namespace namespace meta { at::Tensor erfinv(const at::Tensor & self) { return wrapper_Meta_erfinv(self); } at::Tensor & erfinv_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_erfinv_out_out(self, out); } at::Tensor & erfinv_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_erfinv_out_out(self, out); } at::Tensor & erfinv_(at::Tensor & self) { return wrapper_Meta_erfinv_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_i0_meta_functional final : public at::meta::structured_i0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_i0(const at::Tensor & self) { structured_i0_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_i0_meta_out final : public at::meta::structured_i0 { structured_i0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_i0_out_out(const at::Tensor & self, at::Tensor & out) { structured_i0_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_i0_meta_inplace final : public at::meta::structured_i0 { structured_i0_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_i0_(at::Tensor & self) { structured_i0_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("i0", TORCH_FN(wrapper_Meta_i0)); m.impl("i0.out", TORCH_FN(wrapper_Meta_i0_out_out)); m.impl("i0_", TORCH_FN(wrapper_Meta_i0_)); } } // anonymous namespace namespace meta { at::Tensor i0(const at::Tensor & self) { return wrapper_Meta_i0(self); } at::Tensor & i0_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_i0_out_out(self, out); } at::Tensor & i0_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_i0_out_out(self, out); } at::Tensor & i0_(at::Tensor & self) { return wrapper_Meta_i0_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sign_meta_functional final : public at::meta::structured_sign { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sign(const at::Tensor & self) { structured_sign_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_sign_meta_out final : public at::meta::structured_sign { structured_sign_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sign_out_out(const at::Tensor & self, at::Tensor & out) { structured_sign_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_sign_meta_inplace final : public at::meta::structured_sign { structured_sign_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sign::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sign_(at::Tensor & self) { structured_sign_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sign", TORCH_FN(wrapper_Meta_sign)); m.impl("sign.out", TORCH_FN(wrapper_Meta_sign_out_out)); m.impl("sign_", TORCH_FN(wrapper_Meta_sign_)); } } // anonymous namespace namespace meta { at::Tensor sign(const at::Tensor & self) { return wrapper_Meta_sign(self); } at::Tensor & sign_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_sign_out_out(self, out); } at::Tensor & sign_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_sign_out_out(self, out); } at::Tensor & sign_(at::Tensor & self) { return wrapper_Meta_sign_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_signbit_meta_functional final : public at::meta::structured_signbit { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_signbit::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_signbit::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_signbit(const at::Tensor & self) { structured_signbit_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_signbit_meta_out final : public at::meta::structured_signbit { structured_signbit_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_signbit::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_signbit::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_signbit_out_out(const at::Tensor & self, at::Tensor & out) { structured_signbit_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("signbit", TORCH_FN(wrapper_Meta_signbit)); m.impl("signbit.out", TORCH_FN(wrapper_Meta_signbit_out_out)); } } // anonymous namespace namespace meta { at::Tensor signbit(const at::Tensor & self) { return wrapper_Meta_signbit(self); } at::Tensor & signbit_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_signbit_out_out(self, out); } at::Tensor & signbit_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_signbit_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_atan2_meta_functional final : public at::meta::structured_atan2 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_atan2(const at::Tensor & self, const at::Tensor & other) { structured_atan2_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_atan2_meta_out final : public at::meta::structured_atan2 { structured_atan2_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atan2_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_atan2_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_atan2_meta_inplace final : public at::meta::structured_atan2 { structured_atan2_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_atan2::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_atan2_(at::Tensor & self, const at::Tensor & other) { structured_atan2_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("atan2", TORCH_FN(wrapper_Meta_atan2)); m.impl("atan2.out", TORCH_FN(wrapper_Meta_atan2_out_out)); m.impl("atan2_", TORCH_FN(wrapper_Meta_atan2_)); } } // anonymous namespace namespace meta { at::Tensor atan2(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_atan2(self, other); } at::Tensor & atan2_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_atan2_out_out(self, other, out); } at::Tensor & atan2_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_atan2_out_out(self, other, out); } at::Tensor & atan2_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_atan2_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fmod_Tensor_meta_functional final : public at::meta::structured_fmod_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_fmod_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_fmod_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_fmod_Tensor_meta_out final : public at::meta::structured_fmod_Tensor { structured_fmod_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_fmod_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_fmod_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_fmod_Tensor_meta_inplace final : public at::meta::structured_fmod_Tensor { structured_fmod_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmod_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_fmod__Tensor(at::Tensor & self, const at::Tensor & other) { structured_fmod_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fmod.Tensor", TORCH_FN(wrapper_Meta_fmod_Tensor)); m.impl("fmod.Tensor_out", TORCH_FN(wrapper_Meta_fmod_out_Tensor_out)); m.impl("fmod_.Tensor", TORCH_FN(wrapper_Meta_fmod__Tensor)); } } // anonymous namespace namespace meta { at::Tensor fmod(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmod_Tensor(self, other); } at::Tensor & fmod_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmod_out_Tensor_out(self, other, out); } at::Tensor & fmod_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_fmod_out_Tensor_out(self, other, out); } at::Tensor & fmod_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmod__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_hypot_meta_functional final : public at::meta::structured_hypot { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_hypot(const at::Tensor & self, const at::Tensor & other) { structured_hypot_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_hypot_meta_out final : public at::meta::structured_hypot { structured_hypot_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hypot_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_hypot_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_hypot_meta_inplace final : public at::meta::structured_hypot { structured_hypot_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hypot::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hypot_(at::Tensor & self, const at::Tensor & other) { structured_hypot_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hypot", TORCH_FN(wrapper_Meta_hypot)); m.impl("hypot.out", TORCH_FN(wrapper_Meta_hypot_out_out)); m.impl("hypot_", TORCH_FN(wrapper_Meta_hypot_)); } } // anonymous namespace namespace meta { at::Tensor hypot(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_hypot(self, other); } at::Tensor & hypot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_hypot_out_out(self, other, out); } at::Tensor & hypot_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_hypot_out_out(self, other, out); } at::Tensor & hypot_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_hypot_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_igamma_meta_functional final : public at::meta::structured_igamma { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_igamma(const at::Tensor & self, const at::Tensor & other) { structured_igamma_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_igamma_meta_out final : public at::meta::structured_igamma { structured_igamma_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_igamma_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_igamma_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_igamma_meta_inplace final : public at::meta::structured_igamma { structured_igamma_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igamma::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_igamma_(at::Tensor & self, const at::Tensor & other) { structured_igamma_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("igamma", TORCH_FN(wrapper_Meta_igamma)); m.impl("igamma.out", TORCH_FN(wrapper_Meta_igamma_out_out)); m.impl("igamma_", TORCH_FN(wrapper_Meta_igamma_)); } } // anonymous namespace namespace meta { at::Tensor igamma(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igamma(self, other); } at::Tensor & igamma_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igamma_out_out(self, other, out); } at::Tensor & igamma_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_igamma_out_out(self, other, out); } at::Tensor & igamma_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igamma_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_igammac_meta_functional final : public at::meta::structured_igammac { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_igammac(const at::Tensor & self, const at::Tensor & other) { structured_igammac_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_igammac_meta_out final : public at::meta::structured_igammac { structured_igammac_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_igammac_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_igammac_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_igammac_meta_inplace final : public at::meta::structured_igammac { structured_igammac_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_igammac::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_igammac_(at::Tensor & self, const at::Tensor & other) { structured_igammac_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("igammac", TORCH_FN(wrapper_Meta_igammac)); m.impl("igammac.out", TORCH_FN(wrapper_Meta_igammac_out_out)); m.impl("igammac_", TORCH_FN(wrapper_Meta_igammac_)); } } // anonymous namespace namespace meta { at::Tensor igammac(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igammac(self, other); } at::Tensor & igammac_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igammac_out_out(self, other, out); } at::Tensor & igammac_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_igammac_out_out(self, other, out); } at::Tensor & igammac_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_igammac_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_nextafter_meta_functional final : public at::meta::structured_nextafter { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_nextafter(const at::Tensor & self, const at::Tensor & other) { structured_nextafter_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_nextafter_meta_out final : public at::meta::structured_nextafter { structured_nextafter_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_nextafter_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_nextafter_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_nextafter_meta_inplace final : public at::meta::structured_nextafter { structured_nextafter_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_nextafter::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_nextafter_(at::Tensor & self, const at::Tensor & other) { structured_nextafter_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("nextafter", TORCH_FN(wrapper_Meta_nextafter)); m.impl("nextafter.out", TORCH_FN(wrapper_Meta_nextafter_out_out)); m.impl("nextafter_", TORCH_FN(wrapper_Meta_nextafter_)); } } // anonymous namespace namespace meta { at::Tensor nextafter(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_nextafter(self, other); } at::Tensor & nextafter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_nextafter_out_out(self, other, out); } at::Tensor & nextafter_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_nextafter_out_out(self, other, out); } at::Tensor & nextafter_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_nextafter_(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_remainder_Tensor_meta_functional final : public at::meta::structured_remainder_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_remainder_Tensor(const at::Tensor & self, const at::Tensor & other) { structured_remainder_Tensor_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_remainder_Tensor_meta_out final : public at::meta::structured_remainder_Tensor { structured_remainder_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_remainder_out_Tensor_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_remainder_Tensor_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_remainder_Tensor_meta_inplace final : public at::meta::structured_remainder_Tensor { structured_remainder_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_remainder_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_remainder__Tensor(at::Tensor & self, const at::Tensor & other) { structured_remainder_Tensor_meta_inplace op(self); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("remainder.Tensor", TORCH_FN(wrapper_Meta_remainder_Tensor)); m.impl("remainder.Tensor_out", TORCH_FN(wrapper_Meta_remainder_out_Tensor_out)); m.impl("remainder_.Tensor", TORCH_FN(wrapper_Meta_remainder__Tensor)); } } // anonymous namespace namespace meta { at::Tensor remainder(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_remainder_Tensor(self, other); } at::Tensor & remainder_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_remainder_out_Tensor_out(self, other, out); } at::Tensor & remainder_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_remainder_out_Tensor_out(self, other, out); } at::Tensor & remainder_(at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_remainder__Tensor(self, other); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fmin_meta_functional final : public at::meta::structured_fmin { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_fmin(const at::Tensor & self, const at::Tensor & other) { structured_fmin_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_fmin_meta_out final : public at::meta::structured_fmin { structured_fmin_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmin::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmin::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_fmin_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_fmin_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fmin", TORCH_FN(wrapper_Meta_fmin)); m.impl("fmin.out", TORCH_FN(wrapper_Meta_fmin_out_out)); } } // anonymous namespace namespace meta { at::Tensor fmin(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmin(self, other); } at::Tensor & fmin_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmin_out_out(self, other, out); } at::Tensor & fmin_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_fmin_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fmax_meta_functional final : public at::meta::structured_fmax { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmax::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmax::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_fmax(const at::Tensor & self, const at::Tensor & other) { structured_fmax_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_fmax_meta_out final : public at::meta::structured_fmax { structured_fmax_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmax::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_fmax::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_fmax_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_fmax_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fmax", TORCH_FN(wrapper_Meta_fmax)); m.impl("fmax.out", TORCH_FN(wrapper_Meta_fmax_out_out)); } } // anonymous namespace namespace meta { at::Tensor fmax(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmax(self, other); } at::Tensor & fmax_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_fmax_out_out(self, other, out); } at::Tensor & fmax_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_fmax_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_maximum_meta_functional final : public at::meta::structured_maximum { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_maximum::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_maximum::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_maximum(const at::Tensor & self, const at::Tensor & other) { structured_maximum_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_maximum_meta_out final : public at::meta::structured_maximum { structured_maximum_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_maximum::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_maximum::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_maximum_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_maximum_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("maximum", TORCH_FN(wrapper_Meta_maximum)); m.impl("maximum.out", TORCH_FN(wrapper_Meta_maximum_out_out)); } } // anonymous namespace namespace meta { at::Tensor maximum(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_maximum(self, other); } at::Tensor & maximum_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_maximum_out_out(self, other, out); } at::Tensor & maximum_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_maximum_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_minimum_meta_functional final : public at::meta::structured_minimum { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_minimum::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_minimum::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_minimum(const at::Tensor & self, const at::Tensor & other) { structured_minimum_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_minimum_meta_out final : public at::meta::structured_minimum { structured_minimum_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_minimum::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_minimum::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_minimum_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_minimum_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("minimum", TORCH_FN(wrapper_Meta_minimum)); m.impl("minimum.out", TORCH_FN(wrapper_Meta_minimum_out_out)); } } // anonymous namespace namespace meta { at::Tensor minimum(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_minimum(self, other); } at::Tensor & minimum_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_minimum_out_out(self, other, out); } at::Tensor & minimum_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_minimum_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sort_stable_meta_functional final : public at::meta::structured_sort_stable { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_sort_stable(const at::Tensor & self, ::std::optional stable, int64_t dim, bool descending) { structured_sort_stable_meta_functional op; op.meta(self, stable, dim, descending); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_sort_stable_meta_out final : public at::meta::structured_sort_stable { structured_sort_stable_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_sort_out_values_stable(const at::Tensor & self, ::std::optional stable, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) { structured_sort_stable_meta_out op(values, indices); op.meta(self, stable, dim, descending); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(values, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sort.stable", TORCH_FN(wrapper_Meta_sort_stable)); m.impl("sort.values_stable", TORCH_FN(wrapper_Meta_sort_out_values_stable)); } } // anonymous namespace namespace meta { ::std::tuple sort(const at::Tensor & self, ::std::optional stable, int64_t dim, bool descending) { return wrapper_Meta_sort_stable(self, stable, dim, descending); } ::std::tuple sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, ::std::optional stable, int64_t dim, bool descending) { return wrapper_Meta_sort_out_values_stable(self, stable, dim, descending, values, indices); } ::std::tuple sort_outf(const at::Tensor & self, ::std::optional stable, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) { return wrapper_Meta_sort_out_values_stable(self, stable, dim, descending, values, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_topk_meta_functional final : public at::meta::structured_topk { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_topk(const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) { structured_topk_meta_functional op; op.meta(self, k, dim, largest, sorted); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_topk_meta_out final : public at::meta::structured_topk { structured_topk_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_topk_out_values(const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, at::Tensor & values, at::Tensor & indices) { structured_topk_meta_out op(values, indices); op.meta(self, k, dim, largest, sorted); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(values, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("topk", TORCH_FN(wrapper_Meta_topk)); m.impl("topk.values", TORCH_FN(wrapper_Meta_topk_out_values)); } } // anonymous namespace namespace meta { ::std::tuple topk(const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) { return wrapper_Meta_topk(self, k, dim, largest, sorted); } ::std::tuple topk_symint(const at::Tensor & self, c10::SymInt k, int64_t dim, bool largest, bool sorted) { return wrapper_Meta_topk(self, k.guard_int(__FILE__, __LINE__), dim, largest, sorted); } ::std::tuple topk_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted) { return wrapper_Meta_topk_out_values(self, k, dim, largest, sorted, values, indices); } ::std::tuple topk_outf(const at::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, at::Tensor & values, at::Tensor & indices) { return wrapper_Meta_topk_out_values(self, k, dim, largest, sorted, values, indices); } ::std::tuple topk_symint_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, c10::SymInt k, int64_t dim, bool largest, bool sorted) { return wrapper_Meta_topk_out_values(self, k.guard_int(__FILE__, __LINE__), dim, largest, sorted, values, indices); } ::std::tuple topk_symint_outf(const at::Tensor & self, c10::SymInt k, int64_t dim, bool largest, bool sorted, at::Tensor & values, at::Tensor & indices) { return wrapper_Meta_topk_out_values(self, k.guard_int(__FILE__, __LINE__), dim, largest, sorted, values, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_all_meta_functional final : public at::meta::structured_all { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_all(const at::Tensor & self) { structured_all_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_all_meta_out final : public at::meta::structured_all { structured_all_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_all_out_all_out(const at::Tensor & self, at::Tensor & out) { structured_all_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("all", TORCH_FN(wrapper_Meta_all)); m.impl("all.all_out", TORCH_FN(wrapper_Meta_all_out_all_out)); } } // anonymous namespace namespace meta { at::Tensor all(const at::Tensor & self) { return wrapper_Meta_all(self); } at::Tensor & all_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_all_out_all_out(self, out); } at::Tensor & all_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_all_out_all_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_any_meta_functional final : public at::meta::structured_any { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_any(const at::Tensor & self) { structured_any_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_any_meta_out final : public at::meta::structured_any { structured_any_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_any_out_all_out(const at::Tensor & self, at::Tensor & out) { structured_any_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("any", TORCH_FN(wrapper_Meta_any)); m.impl("any.all_out", TORCH_FN(wrapper_Meta_any_out_all_out)); } } // anonymous namespace namespace meta { at::Tensor any(const at::Tensor & self) { return wrapper_Meta_any(self); } at::Tensor & any_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_any_out_all_out(self, out); } at::Tensor & any_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_any_out_all_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_renorm_meta_functional final : public at::meta::structured_renorm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_renorm(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm) { structured_renorm_meta_functional op; op.meta(self, p, dim, maxnorm); return std::move(op.outputs_[0]); } struct structured_renorm_meta_out final : public at::meta::structured_renorm { structured_renorm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_renorm_out_out(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm, at::Tensor & out) { structured_renorm_meta_out op(out); op.meta(self, p, dim, maxnorm); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_renorm_meta_inplace final : public at::meta::structured_renorm { structured_renorm_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_renorm_(at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm) { structured_renorm_meta_inplace op(self); op.meta(self, p, dim, maxnorm); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("renorm", TORCH_FN(wrapper_Meta_renorm)); m.impl("renorm.out", TORCH_FN(wrapper_Meta_renorm_out_out)); m.impl("renorm_", TORCH_FN(wrapper_Meta_renorm_)); } } // anonymous namespace namespace meta { at::Tensor renorm(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm) { return wrapper_Meta_renorm(self, p, dim, maxnorm); } at::Tensor & renorm_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm) { return wrapper_Meta_renorm_out_out(self, p, dim, maxnorm, out); } at::Tensor & renorm_outf(const at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm, at::Tensor & out) { return wrapper_Meta_renorm_out_out(self, p, dim, maxnorm, out); } at::Tensor & renorm_(at::Tensor & self, const at::Scalar & p, int64_t dim, const at::Scalar & maxnorm) { return wrapper_Meta_renorm_(self, p, dim, maxnorm); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta__unfold(const at::Tensor & self, int64_t dimension, int64_t size, int64_t step) { // No device check // DeviceGuard omitted return at::native::unfold(self, dimension, size, step); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("unfold", TORCH_FN(wrapper_Meta__unfold)); } } // anonymous namespace namespace meta { at::Tensor unfold(const at::Tensor & self, int64_t dimension, int64_t size, int64_t step) { return wrapper_Meta__unfold(self, dimension, size, step); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_pow_Tensor_Tensor_meta_functional final : public at::meta::structured_pow_Tensor_Tensor { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_pow_Tensor_Tensor(const at::Tensor & self, const at::Tensor & exponent) { structured_pow_Tensor_Tensor_meta_functional op; op.meta(self, exponent); return std::move(op.outputs_[0]); } struct structured_pow_Tensor_Tensor_meta_out final : public at::meta::structured_pow_Tensor_Tensor { structured_pow_Tensor_Tensor_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_pow_out_Tensor_Tensor_out(const at::Tensor & self, const at::Tensor & exponent, at::Tensor & out) { structured_pow_Tensor_Tensor_meta_out op(out); op.meta(self, exponent); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_pow_Tensor_Tensor_meta_inplace final : public at::meta::structured_pow_Tensor_Tensor { structured_pow_Tensor_Tensor_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Tensor::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_pow__Tensor(at::Tensor & self, const at::Tensor & exponent) { structured_pow_Tensor_Tensor_meta_inplace op(self); op.meta(self, exponent); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("pow.Tensor_Tensor", TORCH_FN(wrapper_Meta_pow_Tensor_Tensor)); m.impl("pow.Tensor_Tensor_out", TORCH_FN(wrapper_Meta_pow_out_Tensor_Tensor_out)); m.impl("pow_.Tensor", TORCH_FN(wrapper_Meta_pow__Tensor)); } } // anonymous namespace namespace meta { at::Tensor pow(const at::Tensor & self, const at::Tensor & exponent) { return wrapper_Meta_pow_Tensor_Tensor(self, exponent); } at::Tensor & pow_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & exponent) { return wrapper_Meta_pow_out_Tensor_Tensor_out(self, exponent, out); } at::Tensor & pow_outf(const at::Tensor & self, const at::Tensor & exponent, at::Tensor & out) { return wrapper_Meta_pow_out_Tensor_Tensor_out(self, exponent, out); } at::Tensor & pow_(at::Tensor & self, const at::Tensor & exponent) { return wrapper_Meta_pow__Tensor(self, exponent); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_pow_Scalar_meta_functional final : public at::meta::structured_pow_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_pow_Scalar(const at::Scalar & self, const at::Tensor & exponent) { structured_pow_Scalar_meta_functional op; op.meta(self, exponent); return std::move(op.outputs_[0]); } struct structured_pow_Scalar_meta_out final : public at::meta::structured_pow_Scalar { structured_pow_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_pow_out_Scalar_out(const at::Scalar & self, const at::Tensor & exponent, at::Tensor & out) { structured_pow_Scalar_meta_out op(out); op.meta(self, exponent); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("pow.Scalar", TORCH_FN(wrapper_Meta_pow_Scalar)); m.impl("pow.Scalar_out", TORCH_FN(wrapper_Meta_pow_out_Scalar_out)); } } // anonymous namespace namespace meta { at::Tensor pow(const at::Scalar & self, const at::Tensor & exponent) { return wrapper_Meta_pow_Scalar(self, exponent); } at::Tensor & pow_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & exponent) { return wrapper_Meta_pow_out_Scalar_out(self, exponent, out); } at::Tensor & pow_outf(const at::Scalar & self, const at::Tensor & exponent, at::Tensor & out) { return wrapper_Meta_pow_out_Scalar_out(self, exponent, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_pow_Tensor_Scalar_meta_functional final : public at::meta::structured_pow_Tensor_Scalar { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_pow_Tensor_Scalar(const at::Tensor & self, const at::Scalar & exponent) { structured_pow_Tensor_Scalar_meta_functional op; op.meta(self, exponent); return std::move(op.outputs_[0]); } struct structured_pow_Tensor_Scalar_meta_out final : public at::meta::structured_pow_Tensor_Scalar { structured_pow_Tensor_Scalar_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_pow_out_Tensor_Scalar_out(const at::Tensor & self, const at::Scalar & exponent, at::Tensor & out) { structured_pow_Tensor_Scalar_meta_out op(out); op.meta(self, exponent); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_pow_Tensor_Scalar_meta_inplace final : public at::meta::structured_pow_Tensor_Scalar { structured_pow_Tensor_Scalar_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_pow_Tensor_Scalar::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_pow__Scalar(at::Tensor & self, const at::Scalar & exponent) { structured_pow_Tensor_Scalar_meta_inplace op(self); op.meta(self, exponent); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("pow.Tensor_Scalar", TORCH_FN(wrapper_Meta_pow_Tensor_Scalar)); m.impl("pow.Tensor_Scalar_out", TORCH_FN(wrapper_Meta_pow_out_Tensor_Scalar_out)); m.impl("pow_.Scalar", TORCH_FN(wrapper_Meta_pow__Scalar)); } } // anonymous namespace namespace meta { at::Tensor pow(const at::Tensor & self, const at::Scalar & exponent) { return wrapper_Meta_pow_Tensor_Scalar(self, exponent); } at::Tensor & pow_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & exponent) { return wrapper_Meta_pow_out_Tensor_Scalar_out(self, exponent, out); } at::Tensor & pow_outf(const at::Tensor & self, const at::Scalar & exponent, at::Tensor & out) { return wrapper_Meta_pow_out_Tensor_Scalar_out(self, exponent, out); } at::Tensor & pow_(at::Tensor & self, const at::Scalar & exponent) { return wrapper_Meta_pow__Scalar(self, exponent); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor & wrapper_Meta__normal_(at::Tensor & self, double mean, double std, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::normal_meta_(self, mean, std, generator); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("normal_", TORCH_FN(wrapper_Meta__normal_)); } } // anonymous namespace namespace meta { at::Tensor & normal_(at::Tensor & self, double mean, double std, ::std::optional generator) { return wrapper_Meta__normal_(self, mean, std, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta_Tensor_float_normal(const at::Tensor & mean, double std, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::normal_meta(mean, std, generator); } } // anonymous namespace namespace { at::Tensor & wrapper_Meta_Tensor_float_out_normal_out(const at::Tensor & mean, double std, ::std::optional generator, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::normal_out_meta(mean, std, generator, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("normal.Tensor_float", TORCH_FN(wrapper_Meta_Tensor_float_normal)); m.impl("normal.Tensor_float_out", TORCH_FN(wrapper_Meta_Tensor_float_out_normal_out)); } } // anonymous namespace namespace meta { at::Tensor normal(const at::Tensor & mean, double std, ::std::optional generator) { return wrapper_Meta_Tensor_float_normal(mean, std, generator); } at::Tensor & normal_out(at::Tensor & out, const at::Tensor & mean, double std, ::std::optional generator) { return wrapper_Meta_Tensor_float_out_normal_out(mean, std, generator, out); } at::Tensor & normal_outf(const at::Tensor & mean, double std, ::std::optional generator, at::Tensor & out) { return wrapper_Meta_Tensor_float_out_normal_out(mean, std, generator, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta_float_Tensor_normal(double mean, const at::Tensor & std, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::normal_meta(mean, std, generator); } } // anonymous namespace namespace { at::Tensor & wrapper_Meta_float_Tensor_out_normal_out(double mean, const at::Tensor & std, ::std::optional generator, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::normal_out_meta(mean, std, generator, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("normal.float_Tensor", TORCH_FN(wrapper_Meta_float_Tensor_normal)); m.impl("normal.float_Tensor_out", TORCH_FN(wrapper_Meta_float_Tensor_out_normal_out)); } } // anonymous namespace namespace meta { at::Tensor normal(double mean, const at::Tensor & std, ::std::optional generator) { return wrapper_Meta_float_Tensor_normal(mean, std, generator); } at::Tensor & normal_out(at::Tensor & out, double mean, const at::Tensor & std, ::std::optional generator) { return wrapper_Meta_float_Tensor_out_normal_out(mean, std, generator, out); } at::Tensor & normal_outf(double mean, const at::Tensor & std, ::std::optional generator, at::Tensor & out) { return wrapper_Meta_float_Tensor_out_normal_out(mean, std, generator, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { at::Tensor wrapper_Meta_Tensor_Tensor_normal(const at::Tensor & mean, const at::Tensor & std, ::std::optional generator) { // No device check // DeviceGuard omitted return at::native::normal_meta(mean, std, generator); } } // anonymous namespace namespace { at::Tensor & wrapper_Meta_Tensor_Tensor_out_normal_out(const at::Tensor & mean, const at::Tensor & std, ::std::optional generator, at::Tensor & out) { // No device check // DeviceGuard omitted return at::native::normal_out_meta(mean, std, generator, out); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("normal.Tensor_Tensor", TORCH_FN(wrapper_Meta_Tensor_Tensor_normal)); m.impl("normal.Tensor_Tensor_out", TORCH_FN(wrapper_Meta_Tensor_Tensor_out_normal_out)); } } // anonymous namespace namespace meta { at::Tensor normal(const at::Tensor & mean, const at::Tensor & std, ::std::optional generator) { return wrapper_Meta_Tensor_Tensor_normal(mean, std, generator); } at::Tensor & normal_out(at::Tensor & out, const at::Tensor & mean, const at::Tensor & std, ::std::optional generator) { return wrapper_Meta_Tensor_Tensor_out_normal_out(mean, std, generator, out); } at::Tensor & normal_outf(const at::Tensor & mean, const at::Tensor & std, ::std::optional generator, at::Tensor & out) { return wrapper_Meta_Tensor_Tensor_out_normal_out(mean, std, generator, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta___amp_update_scale_(at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_amp_update_scale_", TORCH_FN(wrapper_Meta___amp_update_scale_)); } } // anonymous namespace namespace meta { at::Tensor & _amp_update_scale_(at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) { return wrapper_Meta___amp_update_scale_(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__convert_indices_from_coo_to_csr_meta_functional final : public at::meta::structured__convert_indices_from_coo_to_csr { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__convert_indices_from_coo_to_csr(const at::Tensor & self, int64_t size, bool out_int32) { structured__convert_indices_from_coo_to_csr_meta_functional op; op.meta(self, size, out_int32); return std::move(op.outputs_[0]); } struct structured__convert_indices_from_coo_to_csr_meta_out final : public at::meta::structured__convert_indices_from_coo_to_csr { structured__convert_indices_from_coo_to_csr_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__convert_indices_from_coo_to_csr_out_out(const at::Tensor & self, int64_t size, bool out_int32, at::Tensor & out) { structured__convert_indices_from_coo_to_csr_meta_out op(out); op.meta(self, size, out_int32); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_convert_indices_from_coo_to_csr", TORCH_FN(wrapper_Meta__convert_indices_from_coo_to_csr)); m.impl("_convert_indices_from_coo_to_csr.out", TORCH_FN(wrapper_Meta__convert_indices_from_coo_to_csr_out_out)); } } // anonymous namespace namespace meta { at::Tensor _convert_indices_from_coo_to_csr(const at::Tensor & self, int64_t size, bool out_int32) { return wrapper_Meta__convert_indices_from_coo_to_csr(self, size, out_int32); } at::Tensor & _convert_indices_from_coo_to_csr_out(at::Tensor & out, const at::Tensor & self, int64_t size, bool out_int32) { return wrapper_Meta__convert_indices_from_coo_to_csr_out_out(self, size, out_int32, out); } at::Tensor & _convert_indices_from_coo_to_csr_outf(const at::Tensor & self, int64_t size, bool out_int32, at::Tensor & out) { return wrapper_Meta__convert_indices_from_coo_to_csr_out_out(self, size, out_int32, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__convert_indices_from_csr_to_coo_meta_functional final : public at::meta::structured__convert_indices_from_csr_to_coo { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__convert_indices_from_csr_to_coo(const at::Tensor & crow_indices, const at::Tensor & col_indices, bool out_int32, bool transpose) { structured__convert_indices_from_csr_to_coo_meta_functional op; op.meta(crow_indices, col_indices, out_int32, transpose); return std::move(op.outputs_[0]); } struct structured__convert_indices_from_csr_to_coo_meta_out final : public at::meta::structured__convert_indices_from_csr_to_coo { structured__convert_indices_from_csr_to_coo_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__convert_indices_from_csr_to_coo_out_out(const at::Tensor & crow_indices, const at::Tensor & col_indices, bool out_int32, bool transpose, at::Tensor & out) { structured__convert_indices_from_csr_to_coo_meta_out op(out); op.meta(crow_indices, col_indices, out_int32, transpose); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_convert_indices_from_csr_to_coo", TORCH_FN(wrapper_Meta__convert_indices_from_csr_to_coo)); m.impl("_convert_indices_from_csr_to_coo.out", TORCH_FN(wrapper_Meta__convert_indices_from_csr_to_coo_out_out)); } } // anonymous namespace namespace meta { at::Tensor _convert_indices_from_csr_to_coo(const at::Tensor & crow_indices, const at::Tensor & col_indices, bool out_int32, bool transpose) { return wrapper_Meta__convert_indices_from_csr_to_coo(crow_indices, col_indices, out_int32, transpose); } at::Tensor & _convert_indices_from_csr_to_coo_out(at::Tensor & out, const at::Tensor & crow_indices, const at::Tensor & col_indices, bool out_int32, bool transpose) { return wrapper_Meta__convert_indices_from_csr_to_coo_out_out(crow_indices, col_indices, out_int32, transpose, out); } at::Tensor & _convert_indices_from_csr_to_coo_outf(const at::Tensor & crow_indices, const at::Tensor & col_indices, bool out_int32, bool transpose, at::Tensor & out) { return wrapper_Meta__convert_indices_from_csr_to_coo_out_out(crow_indices, col_indices, out_int32, transpose, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_mse_loss_meta_functional final : public at::meta::structured_mse_loss { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mse_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mse_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_mse_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction) { structured_mse_loss_meta_functional op; op.meta(self, target, reduction); return std::move(op.outputs_[0]); } struct structured_mse_loss_meta_out final : public at::meta::structured_mse_loss { structured_mse_loss_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mse_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_mse_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_mse_loss_out_out(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out) { structured_mse_loss_meta_out op(out); op.meta(self, target, reduction); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("mse_loss", TORCH_FN(wrapper_Meta_mse_loss)); m.impl("mse_loss.out", TORCH_FN(wrapper_Meta_mse_loss_out_out)); } } // anonymous namespace namespace meta { at::Tensor mse_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction) { return wrapper_Meta_mse_loss(self, target, reduction); } at::Tensor & mse_loss_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, int64_t reduction) { return wrapper_Meta_mse_loss_out_out(self, target, reduction, out); } at::Tensor & mse_loss_outf(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out) { return wrapper_Meta_mse_loss_out_out(self, target, reduction, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_nll_loss_forward_meta_functional final : public at::meta::structured_nll_loss_forward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_nll_loss_forward(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index) { structured_nll_loss_forward_meta_functional op; op.meta(self, target, ((weight.has_value() && (*weight).defined()) ? at::OptionalTensorRef(*weight) : at::OptionalTensorRef()), reduction, ignore_index); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_nll_loss_forward_meta_out final : public at::meta::structured_nll_loss_forward { structured_nll_loss_forward_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_nll_loss_forward_out_output(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, at::Tensor & output, at::Tensor & total_weight) { structured_nll_loss_forward_meta_out op(output, total_weight); op.meta(self, target, ((weight.has_value() && (*weight).defined()) ? at::OptionalTensorRef(*weight) : at::OptionalTensorRef()), reduction, ignore_index); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(output, total_weight); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("nll_loss_forward", TORCH_FN(wrapper_Meta_nll_loss_forward)); m.impl("nll_loss_forward.output", TORCH_FN(wrapper_Meta_nll_loss_forward_out_output)); } } // anonymous namespace namespace meta { ::std::tuple nll_loss_forward(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index) { return wrapper_Meta_nll_loss_forward(self, target, weight, reduction, ignore_index); } ::std::tuple nll_loss_forward_symint(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index) { return wrapper_Meta_nll_loss_forward(self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__)); } ::std::tuple nll_loss_forward_out(at::Tensor & output, at::Tensor & total_weight, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index) { return wrapper_Meta_nll_loss_forward_out_output(self, target, weight, reduction, ignore_index, output, total_weight); } ::std::tuple nll_loss_forward_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, at::Tensor & output, at::Tensor & total_weight) { return wrapper_Meta_nll_loss_forward_out_output(self, target, weight, reduction, ignore_index, output, total_weight); } ::std::tuple nll_loss_forward_symint_out(at::Tensor & output, at::Tensor & total_weight, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index) { return wrapper_Meta_nll_loss_forward_out_output(self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__), output, total_weight); } ::std::tuple nll_loss_forward_symint_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index, at::Tensor & output, at::Tensor & total_weight) { return wrapper_Meta_nll_loss_forward_out_output(self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__), output, total_weight); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_nll_loss_backward_meta_functional final : public at::meta::structured_nll_loss_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_nll_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, const at::Tensor & total_weight) { structured_nll_loss_backward_meta_functional op; op.meta(grad_output, self, target, ((weight.has_value() && (*weight).defined()) ? at::OptionalTensorRef(*weight) : at::OptionalTensorRef()), reduction, ignore_index, total_weight); return std::move(op.outputs_[0]); } struct structured_nll_loss_backward_meta_out final : public at::meta::structured_nll_loss_backward { structured_nll_loss_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_nll_loss_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, const at::Tensor & total_weight, at::Tensor & grad_input) { structured_nll_loss_backward_meta_out op(grad_input); op.meta(grad_output, self, target, ((weight.has_value() && (*weight).defined()) ? at::OptionalTensorRef(*weight) : at::OptionalTensorRef()), reduction, ignore_index, total_weight); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("nll_loss_backward", TORCH_FN(wrapper_Meta_nll_loss_backward)); m.impl("nll_loss_backward.grad_input", TORCH_FN(wrapper_Meta_nll_loss_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor nll_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, const at::Tensor & total_weight) { return wrapper_Meta_nll_loss_backward(grad_output, self, target, weight, reduction, ignore_index, total_weight); } at::Tensor nll_loss_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index, const at::Tensor & total_weight) { return wrapper_Meta_nll_loss_backward(grad_output, self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__), total_weight); } at::Tensor & nll_loss_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, const at::Tensor & total_weight) { return wrapper_Meta_nll_loss_backward_out_grad_input(grad_output, self, target, weight, reduction, ignore_index, total_weight, grad_input); } at::Tensor & nll_loss_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, int64_t ignore_index, const at::Tensor & total_weight, at::Tensor & grad_input) { return wrapper_Meta_nll_loss_backward_out_grad_input(grad_output, self, target, weight, reduction, ignore_index, total_weight, grad_input); } at::Tensor & nll_loss_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index, const at::Tensor & total_weight) { return wrapper_Meta_nll_loss_backward_out_grad_input(grad_output, self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__), total_weight, grad_input); } at::Tensor & nll_loss_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, const ::std::optional & weight, int64_t reduction, c10::SymInt ignore_index, const at::Tensor & total_weight, at::Tensor & grad_input) { return wrapper_Meta_nll_loss_backward_out_grad_input(grad_output, self, target, weight, reduction, ignore_index.guard_int(__FILE__, __LINE__), total_weight, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_smooth_l1_loss_meta_functional final : public at::meta::structured_smooth_l1_loss { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_smooth_l1_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_smooth_l1_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_smooth_l1_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta) { structured_smooth_l1_loss_meta_functional op; op.meta(self, target, reduction, beta); return std::move(op.outputs_[0]); } struct structured_smooth_l1_loss_meta_out final : public at::meta::structured_smooth_l1_loss { structured_smooth_l1_loss_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_smooth_l1_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_smooth_l1_loss::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_smooth_l1_loss_out_out(const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta, at::Tensor & out) { structured_smooth_l1_loss_meta_out op(out); op.meta(self, target, reduction, beta); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("smooth_l1_loss", TORCH_FN(wrapper_Meta_smooth_l1_loss)); m.impl("smooth_l1_loss.out", TORCH_FN(wrapper_Meta_smooth_l1_loss_out_out)); } } // anonymous namespace namespace meta { at::Tensor smooth_l1_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta) { return wrapper_Meta_smooth_l1_loss(self, target, reduction, beta); } at::Tensor & smooth_l1_loss_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta) { return wrapper_Meta_smooth_l1_loss_out_out(self, target, reduction, beta, out); } at::Tensor & smooth_l1_loss_outf(const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta, at::Tensor & out) { return wrapper_Meta_smooth_l1_loss_out_out(self, target, reduction, beta, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_elu_meta_functional final : public at::meta::structured_elu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_elu(const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale) { structured_elu_meta_functional op; op.meta(self, alpha, scale, input_scale); return std::move(op.outputs_[0]); } struct structured_elu_meta_out final : public at::meta::structured_elu { structured_elu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_elu_out_out(const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, at::Tensor & out) { structured_elu_meta_out op(out); op.meta(self, alpha, scale, input_scale); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_elu_meta_inplace final : public at::meta::structured_elu { structured_elu_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_elu_(at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale) { structured_elu_meta_inplace op(self); op.meta(self, alpha, scale, input_scale); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("elu", TORCH_FN(wrapper_Meta_elu)); m.impl("elu.out", TORCH_FN(wrapper_Meta_elu_out_out)); m.impl("elu_", TORCH_FN(wrapper_Meta_elu_)); } } // anonymous namespace namespace meta { at::Tensor elu(const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale) { return wrapper_Meta_elu(self, alpha, scale, input_scale); } at::Tensor & elu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale) { return wrapper_Meta_elu_out_out(self, alpha, scale, input_scale, out); } at::Tensor & elu_outf(const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, at::Tensor & out) { return wrapper_Meta_elu_out_out(self, alpha, scale, input_scale, out); } at::Tensor & elu_(at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale) { return wrapper_Meta_elu_(self, alpha, scale, input_scale); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_elu_backward_meta_functional final : public at::meta::structured_elu_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_elu_backward(const at::Tensor & grad_output, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, bool is_result, const at::Tensor & self_or_result) { structured_elu_backward_meta_functional op; op.meta(grad_output, alpha, scale, input_scale, is_result, self_or_result); return std::move(op.outputs_[0]); } struct structured_elu_backward_meta_out final : public at::meta::structured_elu_backward { structured_elu_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_elu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_elu_backward_out_grad_input(const at::Tensor & grad_output, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, bool is_result, const at::Tensor & self_or_result, at::Tensor & grad_input) { structured_elu_backward_meta_out op(grad_input); op.meta(grad_output, alpha, scale, input_scale, is_result, self_or_result); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("elu_backward", TORCH_FN(wrapper_Meta_elu_backward)); m.impl("elu_backward.grad_input", TORCH_FN(wrapper_Meta_elu_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor elu_backward(const at::Tensor & grad_output, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, bool is_result, const at::Tensor & self_or_result) { return wrapper_Meta_elu_backward(grad_output, alpha, scale, input_scale, is_result, self_or_result); } at::Tensor & elu_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, bool is_result, const at::Tensor & self_or_result) { return wrapper_Meta_elu_backward_out_grad_input(grad_output, alpha, scale, input_scale, is_result, self_or_result, grad_input); } at::Tensor & elu_backward_outf(const at::Tensor & grad_output, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, bool is_result, const at::Tensor & self_or_result, at::Tensor & grad_input) { return wrapper_Meta_elu_backward_out_grad_input(grad_output, alpha, scale, input_scale, is_result, self_or_result, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_glu_meta_functional final : public at::meta::structured_glu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_glu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_glu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_glu(const at::Tensor & self, int64_t dim) { structured_glu_meta_functional op; op.meta(self, dim); return std::move(op.outputs_[0]); } struct structured_glu_meta_out final : public at::meta::structured_glu { structured_glu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_glu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_glu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_glu_out_out(const at::Tensor & self, int64_t dim, at::Tensor & out) { structured_glu_meta_out op(out); op.meta(self, dim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("glu", TORCH_FN(wrapper_Meta_glu)); m.impl("glu.out", TORCH_FN(wrapper_Meta_glu_out_out)); } } // anonymous namespace namespace meta { at::Tensor glu(const at::Tensor & self, int64_t dim) { return wrapper_Meta_glu(self, dim); } at::Tensor & glu_out(at::Tensor & out, const at::Tensor & self, int64_t dim) { return wrapper_Meta_glu_out_out(self, dim, out); } at::Tensor & glu_outf(const at::Tensor & self, int64_t dim, at::Tensor & out) { return wrapper_Meta_glu_out_out(self, dim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_hardsigmoid_meta_functional final : public at::meta::structured_hardsigmoid { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_hardsigmoid(const at::Tensor & self) { structured_hardsigmoid_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_hardsigmoid_meta_out final : public at::meta::structured_hardsigmoid { structured_hardsigmoid_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hardsigmoid_out_out(const at::Tensor & self, at::Tensor & out) { structured_hardsigmoid_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_hardsigmoid_meta_inplace final : public at::meta::structured_hardsigmoid { structured_hardsigmoid_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hardsigmoid_(at::Tensor & self) { structured_hardsigmoid_meta_inplace op(self); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardsigmoid", TORCH_FN(wrapper_Meta_hardsigmoid)); m.impl("hardsigmoid.out", TORCH_FN(wrapper_Meta_hardsigmoid_out_out)); m.impl("hardsigmoid_", TORCH_FN(wrapper_Meta_hardsigmoid_)); } } // anonymous namespace namespace meta { at::Tensor hardsigmoid(const at::Tensor & self) { return wrapper_Meta_hardsigmoid(self); } at::Tensor & hardsigmoid_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_hardsigmoid_out_out(self, out); } at::Tensor & hardsigmoid_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_hardsigmoid_out_out(self, out); } at::Tensor & hardsigmoid_(at::Tensor & self) { return wrapper_Meta_hardsigmoid_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_hardsigmoid_backward_meta_functional final : public at::meta::structured_hardsigmoid_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_hardsigmoid_backward(const at::Tensor & grad_output, const at::Tensor & self) { structured_hardsigmoid_backward_meta_functional op; op.meta(grad_output, self); return std::move(op.outputs_[0]); } struct structured_hardsigmoid_backward_meta_out final : public at::meta::structured_hardsigmoid_backward { structured_hardsigmoid_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_hardsigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_hardsigmoid_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & grad_input) { structured_hardsigmoid_backward_meta_out op(grad_input); op.meta(grad_output, self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardsigmoid_backward", TORCH_FN(wrapper_Meta_hardsigmoid_backward)); m.impl("hardsigmoid_backward.grad_input", TORCH_FN(wrapper_Meta_hardsigmoid_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor hardsigmoid_backward(const at::Tensor & grad_output, const at::Tensor & self) { return wrapper_Meta_hardsigmoid_backward(grad_output, self); } at::Tensor & hardsigmoid_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self) { return wrapper_Meta_hardsigmoid_backward_out_grad_input(grad_output, self, grad_input); } at::Tensor & hardsigmoid_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & grad_input) { return wrapper_Meta_hardsigmoid_backward_out_grad_input(grad_output, self, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__hardtanh_(at::Tensor & self, const at::Scalar & min_val, const at::Scalar & max_val) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardtanh_", TORCH_FN(wrapper_Meta__hardtanh_)); } } // anonymous namespace namespace meta { at::Tensor & hardtanh_(at::Tensor & self, const at::Scalar & min_val, const at::Scalar & max_val) { return wrapper_Meta__hardtanh_(self, min_val, max_val); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__hardswish_(at::Tensor & self) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("hardswish_", TORCH_FN(wrapper_Meta__hardswish_)); } } // anonymous namespace namespace meta { at::Tensor & hardswish_(at::Tensor & self) { return wrapper_Meta__hardswish_(self); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_leaky_relu_meta_functional final : public at::meta::structured_leaky_relu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_leaky_relu(const at::Tensor & self, const at::Scalar & negative_slope) { structured_leaky_relu_meta_functional op; op.meta(self, negative_slope); return std::move(op.outputs_[0]); } struct structured_leaky_relu_meta_out final : public at::meta::structured_leaky_relu { structured_leaky_relu_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_leaky_relu_out_out(const at::Tensor & self, const at::Scalar & negative_slope, at::Tensor & out) { structured_leaky_relu_meta_out op(out); op.meta(self, negative_slope); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } struct structured_leaky_relu_meta_inplace final : public at::meta::structured_leaky_relu { structured_leaky_relu_meta_inplace(Tensor& self) : outputs_{std::ref(self)} {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); check_inplace(out, sizes, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_leaky_relu_(at::Tensor & self, const at::Scalar & negative_slope) { structured_leaky_relu_meta_inplace op(self); op.meta(self, negative_slope); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("leaky_relu", TORCH_FN(wrapper_Meta_leaky_relu)); m.impl("leaky_relu.out", TORCH_FN(wrapper_Meta_leaky_relu_out_out)); m.impl("leaky_relu_", TORCH_FN(wrapper_Meta_leaky_relu_)); } } // anonymous namespace namespace meta { at::Tensor leaky_relu(const at::Tensor & self, const at::Scalar & negative_slope) { return wrapper_Meta_leaky_relu(self, negative_slope); } at::Tensor & leaky_relu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & negative_slope) { return wrapper_Meta_leaky_relu_out_out(self, negative_slope, out); } at::Tensor & leaky_relu_outf(const at::Tensor & self, const at::Scalar & negative_slope, at::Tensor & out) { return wrapper_Meta_leaky_relu_out_out(self, negative_slope, out); } at::Tensor & leaky_relu_(at::Tensor & self, const at::Scalar & negative_slope) { return wrapper_Meta_leaky_relu_(self, negative_slope); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_leaky_relu_backward_meta_functional final : public at::meta::structured_leaky_relu_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_leaky_relu_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & negative_slope, bool self_is_result) { structured_leaky_relu_backward_meta_functional op; op.meta(grad_output, self, negative_slope, self_is_result); return std::move(op.outputs_[0]); } struct structured_leaky_relu_backward_meta_out final : public at::meta::structured_leaky_relu_backward { structured_leaky_relu_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_leaky_relu_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_leaky_relu_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & negative_slope, bool self_is_result, at::Tensor & grad_input) { structured_leaky_relu_backward_meta_out op(grad_input); op.meta(grad_output, self, negative_slope, self_is_result); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("leaky_relu_backward", TORCH_FN(wrapper_Meta_leaky_relu_backward)); m.impl("leaky_relu_backward.grad_input", TORCH_FN(wrapper_Meta_leaky_relu_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor leaky_relu_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & negative_slope, bool self_is_result) { return wrapper_Meta_leaky_relu_backward(grad_output, self, negative_slope, self_is_result); } at::Tensor & leaky_relu_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & negative_slope, bool self_is_result) { return wrapper_Meta_leaky_relu_backward_out_grad_input(grad_output, self, negative_slope, self_is_result, grad_input); } at::Tensor & leaky_relu_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & negative_slope, bool self_is_result, at::Tensor & grad_input) { return wrapper_Meta_leaky_relu_backward_out_grad_input(grad_output, self, negative_slope, self_is_result, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta__rrelu_with_noise_(at::Tensor & self, at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, ::std::optional generator) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("rrelu_with_noise_", TORCH_FN(wrapper_Meta__rrelu_with_noise_)); } } // anonymous namespace namespace meta { at::Tensor & rrelu_with_noise_(at::Tensor & self, at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, ::std::optional generator) { return wrapper_Meta__rrelu_with_noise_(self, noise, lower, upper, training, generator); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_softplus_meta_functional final : public at::meta::structured_softplus { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_softplus(const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { structured_softplus_meta_functional op; op.meta(self, beta, threshold); return std::move(op.outputs_[0]); } struct structured_softplus_meta_out final : public at::meta::structured_softplus { structured_softplus_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_softplus_out_out(const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold, at::Tensor & out) { structured_softplus_meta_out op(out); op.meta(self, beta, threshold); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("softplus", TORCH_FN(wrapper_Meta_softplus)); m.impl("softplus.out", TORCH_FN(wrapper_Meta_softplus_out_out)); } } // anonymous namespace namespace meta { at::Tensor softplus(const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { return wrapper_Meta_softplus(self, beta, threshold); } at::Tensor & softplus_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { return wrapper_Meta_softplus_out_out(self, beta, threshold, out); } at::Tensor & softplus_outf(const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold, at::Tensor & out) { return wrapper_Meta_softplus_out_out(self, beta, threshold, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_softplus_backward_meta_functional final : public at::meta::structured_softplus_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_softplus_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { structured_softplus_backward_meta_functional op; op.meta(grad_output, self, beta, threshold); return std::move(op.outputs_[0]); } struct structured_softplus_backward_meta_out final : public at::meta::structured_softplus_backward { structured_softplus_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softplus_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_softplus_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold, at::Tensor & grad_input) { structured_softplus_backward_meta_out op(grad_input); op.meta(grad_output, self, beta, threshold); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("softplus_backward", TORCH_FN(wrapper_Meta_softplus_backward)); m.impl("softplus_backward.grad_input", TORCH_FN(wrapper_Meta_softplus_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor softplus_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { return wrapper_Meta_softplus_backward(grad_output, self, beta, threshold); } at::Tensor & softplus_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) { return wrapper_Meta_softplus_backward_out_grad_input(grad_output, self, beta, threshold, grad_input); } at::Tensor & softplus_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold, at::Tensor & grad_input) { return wrapper_Meta_softplus_backward_out_grad_input(grad_output, self, beta, threshold, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_softshrink_meta_functional final : public at::meta::structured_softshrink { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_softshrink(const at::Tensor & self, const at::Scalar & lambd) { structured_softshrink_meta_functional op; op.meta(self, lambd); return std::move(op.outputs_[0]); } struct structured_softshrink_meta_out final : public at::meta::structured_softshrink { structured_softshrink_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_softshrink_out_out(const at::Tensor & self, const at::Scalar & lambd, at::Tensor & out) { structured_softshrink_meta_out op(out); op.meta(self, lambd); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("softshrink", TORCH_FN(wrapper_Meta_softshrink)); m.impl("softshrink.out", TORCH_FN(wrapper_Meta_softshrink_out_out)); } } // anonymous namespace namespace meta { at::Tensor softshrink(const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_softshrink(self, lambd); } at::Tensor & softshrink_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_softshrink_out_out(self, lambd, out); } at::Tensor & softshrink_outf(const at::Tensor & self, const at::Scalar & lambd, at::Tensor & out) { return wrapper_Meta_softshrink_out_out(self, lambd, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_softshrink_backward_meta_functional final : public at::meta::structured_softshrink_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_softshrink_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & lambd) { structured_softshrink_backward_meta_functional op; op.meta(grad_output, self, lambd); return std::move(op.outputs_[0]); } struct structured_softshrink_backward_meta_out final : public at::meta::structured_softshrink_backward { structured_softshrink_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_softshrink_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_softshrink_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & lambd, at::Tensor & grad_input) { structured_softshrink_backward_meta_out op(grad_input); op.meta(grad_output, self, lambd); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("softshrink_backward", TORCH_FN(wrapper_Meta_softshrink_backward)); m.impl("softshrink_backward.grad_input", TORCH_FN(wrapper_Meta_softshrink_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor softshrink_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_softshrink_backward(grad_output, self, lambd); } at::Tensor & softshrink_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & lambd) { return wrapper_Meta_softshrink_backward_out_grad_input(grad_output, self, lambd, grad_input); } at::Tensor & softshrink_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & lambd, at::Tensor & grad_input) { return wrapper_Meta_softshrink_backward_out_grad_input(grad_output, self, lambd, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_adaptive_max_pool2d_meta_functional final : public at::meta::structured_adaptive_max_pool2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_adaptive_max_pool2d(const at::Tensor & self, at::IntArrayRef output_size) { structured_adaptive_max_pool2d_meta_functional op; op.meta(self, output_size); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_adaptive_max_pool2d_meta_out final : public at::meta::structured_adaptive_max_pool2d { structured_adaptive_max_pool2d_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_adaptive_max_pool2d_out_out(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out, at::Tensor & indices) { structured_adaptive_max_pool2d_meta_out op(out, indices); op.meta(self, output_size); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(out, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("adaptive_max_pool2d", TORCH_FN(wrapper_Meta_adaptive_max_pool2d)); m.impl("adaptive_max_pool2d.out", TORCH_FN(wrapper_Meta_adaptive_max_pool2d_out_out)); } } // anonymous namespace namespace meta { ::std::tuple adaptive_max_pool2d(const at::Tensor & self, at::IntArrayRef output_size) { return wrapper_Meta_adaptive_max_pool2d(self, output_size); } ::std::tuple adaptive_max_pool2d_out(at::Tensor & out, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef output_size) { return wrapper_Meta_adaptive_max_pool2d_out_out(self, output_size, out, indices); } ::std::tuple adaptive_max_pool2d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out, at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool2d_out_out(self, output_size, out, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_adaptive_max_pool2d_backward_meta_functional final : public at::meta::structured_adaptive_max_pool2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_adaptive_max_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { structured_adaptive_max_pool2d_backward_meta_functional op; op.meta(grad_output, self, indices); return std::move(op.outputs_[0]); } struct structured_adaptive_max_pool2d_backward_meta_out final : public at::meta::structured_adaptive_max_pool2d_backward { structured_adaptive_max_pool2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_adaptive_max_pool2d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input) { structured_adaptive_max_pool2d_backward_meta_out op(grad_input); op.meta(grad_output, self, indices); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("adaptive_max_pool2d_backward", TORCH_FN(wrapper_Meta_adaptive_max_pool2d_backward)); m.impl("adaptive_max_pool2d_backward.grad_input", TORCH_FN(wrapper_Meta_adaptive_max_pool2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor adaptive_max_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool2d_backward(grad_output, self, indices); } at::Tensor & adaptive_max_pool2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool2d_backward_out_grad_input(grad_output, self, indices, grad_input); } at::Tensor & adaptive_max_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input) { return wrapper_Meta_adaptive_max_pool2d_backward_out_grad_input(grad_output, self, indices, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_adaptive_max_pool3d_meta_functional final : public at::meta::structured_adaptive_max_pool3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_adaptive_max_pool3d(const at::Tensor & self, at::IntArrayRef output_size) { structured_adaptive_max_pool3d_meta_functional op; op.meta(self, output_size); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_adaptive_max_pool3d_meta_out final : public at::meta::structured_adaptive_max_pool3d { structured_adaptive_max_pool3d_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_adaptive_max_pool3d_out_out(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out, at::Tensor & indices) { structured_adaptive_max_pool3d_meta_out op(out, indices); op.meta(self, output_size); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(out, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("adaptive_max_pool3d", TORCH_FN(wrapper_Meta_adaptive_max_pool3d)); m.impl("adaptive_max_pool3d.out", TORCH_FN(wrapper_Meta_adaptive_max_pool3d_out_out)); } } // anonymous namespace namespace meta { ::std::tuple adaptive_max_pool3d(const at::Tensor & self, at::IntArrayRef output_size) { return wrapper_Meta_adaptive_max_pool3d(self, output_size); } ::std::tuple adaptive_max_pool3d_out(at::Tensor & out, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef output_size) { return wrapper_Meta_adaptive_max_pool3d_out_out(self, output_size, out, indices); } ::std::tuple adaptive_max_pool3d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out, at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool3d_out_out(self, output_size, out, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_adaptive_max_pool3d_backward_meta_functional final : public at::meta::structured_adaptive_max_pool3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_adaptive_max_pool3d_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { structured_adaptive_max_pool3d_backward_meta_functional op; op.meta(grad_output, self, indices); return std::move(op.outputs_[0]); } struct structured_adaptive_max_pool3d_backward_meta_out final : public at::meta::structured_adaptive_max_pool3d_backward { structured_adaptive_max_pool3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_adaptive_max_pool3d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input) { structured_adaptive_max_pool3d_backward_meta_out op(grad_input); op.meta(grad_output, self, indices); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("adaptive_max_pool3d_backward", TORCH_FN(wrapper_Meta_adaptive_max_pool3d_backward)); m.impl("adaptive_max_pool3d_backward.grad_input", TORCH_FN(wrapper_Meta_adaptive_max_pool3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor adaptive_max_pool3d_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool3d_backward(grad_output, self, indices); } at::Tensor & adaptive_max_pool3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices) { return wrapper_Meta_adaptive_max_pool3d_backward_out_grad_input(grad_output, self, indices, grad_input); } at::Tensor & adaptive_max_pool3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & indices, at::Tensor & grad_input) { return wrapper_Meta_adaptive_max_pool3d_backward_out_grad_input(grad_output, self, indices, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_avg_pool2d_meta_functional final : public at::meta::structured_avg_pool2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_avg_pool2d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { structured_avg_pool2d_meta_functional op; auto precompute = op.meta(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); (void)precompute; return std::move(op.outputs_[0]); } struct structured_avg_pool2d_meta_out final : public at::meta::structured_avg_pool2d { structured_avg_pool2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_avg_pool2d_out_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & out) { structured_avg_pool2d_meta_out op(out); auto precompute = op.meta(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("avg_pool2d", TORCH_FN(wrapper_Meta_avg_pool2d)); m.impl("avg_pool2d.out", TORCH_FN(wrapper_Meta_avg_pool2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor avg_pool2d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); } at::Tensor & avg_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool2d_out_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, out); } at::Tensor & avg_pool2d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & out) { return wrapper_Meta_avg_pool2d_out_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_avg_pool2d_backward_meta_functional final : public at::meta::structured_avg_pool2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_avg_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { structured_avg_pool2d_backward_meta_functional op; op.meta(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); return std::move(op.outputs_[0]); } struct structured_avg_pool2d_backward_meta_out final : public at::meta::structured_avg_pool2d_backward { structured_avg_pool2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_avg_pool2d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & grad_input) { structured_avg_pool2d_backward_meta_out op(grad_input); op.meta(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("avg_pool2d_backward", TORCH_FN(wrapper_Meta_avg_pool2d_backward)); m.impl("avg_pool2d_backward.grad_input", TORCH_FN(wrapper_Meta_avg_pool2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor avg_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool2d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); } at::Tensor & avg_pool2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool2d_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, grad_input); } at::Tensor & avg_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & grad_input) { return wrapper_Meta_avg_pool2d_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_avg_pool3d_meta_functional final : public at::meta::structured_avg_pool3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_avg_pool3d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { structured_avg_pool3d_meta_functional op; op.meta(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); return std::move(op.outputs_[0]); } struct structured_avg_pool3d_meta_out final : public at::meta::structured_avg_pool3d { structured_avg_pool3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_avg_pool3d_out_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & out) { structured_avg_pool3d_meta_out op(out); op.meta(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("avg_pool3d", TORCH_FN(wrapper_Meta_avg_pool3d)); m.impl("avg_pool3d.out", TORCH_FN(wrapper_Meta_avg_pool3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor avg_pool3d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); } at::Tensor & avg_pool3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool3d_out_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, out); } at::Tensor & avg_pool3d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & out) { return wrapper_Meta_avg_pool3d_out_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_avg_pool3d_backward_meta_functional final : public at::meta::structured_avg_pool3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_avg_pool3d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { structured_avg_pool3d_backward_meta_functional op; op.meta(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); return std::move(op.outputs_[0]); } struct structured_avg_pool3d_backward_meta_out final : public at::meta::structured_avg_pool3d_backward { structured_avg_pool3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_avg_pool3d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & grad_input) { structured_avg_pool3d_backward_meta_out op(grad_input); op.meta(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("avg_pool3d_backward", TORCH_FN(wrapper_Meta_avg_pool3d_backward)); m.impl("avg_pool3d_backward.grad_input", TORCH_FN(wrapper_Meta_avg_pool3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor avg_pool3d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool3d_backward(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override); } at::Tensor & avg_pool3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override) { return wrapper_Meta_avg_pool3d_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, grad_input); } at::Tensor & avg_pool3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, ::std::optional divisor_override, at::Tensor & grad_input) { return wrapper_Meta_avg_pool3d_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fractional_max_pool2d_meta_functional final : public at::meta::structured_fractional_max_pool2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_fractional_max_pool2d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { structured_fractional_max_pool2d_meta_functional op; op.meta(self, kernel_size, output_size, random_samples); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_fractional_max_pool2d_meta_out final : public at::meta::structured_fractional_max_pool2d { structured_fractional_max_pool2d_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_fractional_max_pool2d_out_output(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples, at::Tensor & output, at::Tensor & indices) { structured_fractional_max_pool2d_meta_out op(output, indices); op.meta(self, kernel_size, output_size, random_samples); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(output, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fractional_max_pool2d", TORCH_FN(wrapper_Meta_fractional_max_pool2d)); m.impl("fractional_max_pool2d.output", TORCH_FN(wrapper_Meta_fractional_max_pool2d_out_output)); } } // anonymous namespace namespace meta { ::std::tuple fractional_max_pool2d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { return wrapper_Meta_fractional_max_pool2d(self, kernel_size, output_size, random_samples); } ::std::tuple fractional_max_pool2d_out(at::Tensor & output, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { return wrapper_Meta_fractional_max_pool2d_out_output(self, kernel_size, output_size, random_samples, output, indices); } ::std::tuple fractional_max_pool2d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples, at::Tensor & output, at::Tensor & indices) { return wrapper_Meta_fractional_max_pool2d_out_output(self, kernel_size, output_size, random_samples, output, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fractional_max_pool2d_backward_meta_functional final : public at::meta::structured_fractional_max_pool2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_fractional_max_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices) { structured_fractional_max_pool2d_backward_meta_functional op; op.meta(grad_output, self, kernel_size, output_size, indices); return std::move(op.outputs_[0]); } struct structured_fractional_max_pool2d_backward_meta_out final : public at::meta::structured_fractional_max_pool2d_backward { structured_fractional_max_pool2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_fractional_max_pool2d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices, at::Tensor & grad_input) { structured_fractional_max_pool2d_backward_meta_out op(grad_input); op.meta(grad_output, self, kernel_size, output_size, indices); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fractional_max_pool2d_backward", TORCH_FN(wrapper_Meta_fractional_max_pool2d_backward)); m.impl("fractional_max_pool2d_backward.grad_input", TORCH_FN(wrapper_Meta_fractional_max_pool2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor fractional_max_pool2d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices) { return wrapper_Meta_fractional_max_pool2d_backward(grad_output, self, kernel_size, output_size, indices); } at::Tensor & fractional_max_pool2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices) { return wrapper_Meta_fractional_max_pool2d_backward_out_grad_input(grad_output, self, kernel_size, output_size, indices, grad_input); } at::Tensor & fractional_max_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices, at::Tensor & grad_input) { return wrapper_Meta_fractional_max_pool2d_backward_out_grad_input(grad_output, self, kernel_size, output_size, indices, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_fractional_max_pool3d_meta_functional final : public at::meta::structured_fractional_max_pool3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_fractional_max_pool3d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { structured_fractional_max_pool3d_meta_functional op; auto precompute = op.meta(self, kernel_size, output_size, random_samples); (void)precompute; return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_fractional_max_pool3d_meta_out final : public at::meta::structured_fractional_max_pool3d { structured_fractional_max_pool3d_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_fractional_max_pool3d_out_output(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples, at::Tensor & output, at::Tensor & indices) { structured_fractional_max_pool3d_meta_out op(output, indices); auto precompute = op.meta(self, kernel_size, output_size, random_samples); (void)precompute; if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(output, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("fractional_max_pool3d", TORCH_FN(wrapper_Meta_fractional_max_pool3d)); m.impl("fractional_max_pool3d.output", TORCH_FN(wrapper_Meta_fractional_max_pool3d_out_output)); } } // anonymous namespace namespace meta { ::std::tuple fractional_max_pool3d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { return wrapper_Meta_fractional_max_pool3d(self, kernel_size, output_size, random_samples); } ::std::tuple fractional_max_pool3d_out(at::Tensor & output, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples) { return wrapper_Meta_fractional_max_pool3d_out_output(self, kernel_size, output_size, random_samples, output, indices); } ::std::tuple fractional_max_pool3d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & random_samples, at::Tensor & output, at::Tensor & indices) { return wrapper_Meta_fractional_max_pool3d_out_output(self, kernel_size, output_size, random_samples, output, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_max_pool2d_with_indices_meta_functional final : public at::meta::structured_max_pool2d_with_indices { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_max_pool2d_with_indices(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) { structured_max_pool2d_with_indices_meta_functional op; op.meta(self, kernel_size, stride, padding, dilation, ceil_mode); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_max_pool2d_with_indices_meta_out final : public at::meta::structured_max_pool2d_with_indices { structured_max_pool2d_with_indices_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_max_pool2d_with_indices_out_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out, at::Tensor & indices) { structured_max_pool2d_with_indices_meta_out op(out, indices); op.meta(self, kernel_size, stride, padding, dilation, ceil_mode); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(out, indices); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("max_pool2d_with_indices", TORCH_FN(wrapper_Meta_max_pool2d_with_indices)); m.impl("max_pool2d_with_indices.out", TORCH_FN(wrapper_Meta_max_pool2d_with_indices_out_out)); } } // anonymous namespace namespace meta { ::std::tuple max_pool2d_with_indices(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) { return wrapper_Meta_max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode); } ::std::tuple max_pool2d_with_indices_out(at::Tensor & out, at::Tensor & indices, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) { return wrapper_Meta_max_pool2d_with_indices_out_out(self, kernel_size, stride, padding, dilation, ceil_mode, out, indices); } ::std::tuple max_pool2d_with_indices_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out, at::Tensor & indices) { return wrapper_Meta_max_pool2d_with_indices_out_out(self, kernel_size, stride, padding, dilation, ceil_mode, out, indices); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_max_pool2d_with_indices_backward_meta_functional final : public at::meta::structured_max_pool2d_with_indices_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_max_pool2d_with_indices_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices) { structured_max_pool2d_with_indices_backward_meta_functional op; op.meta(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices); return std::move(op.outputs_[0]); } struct structured_max_pool2d_with_indices_backward_meta_out final : public at::meta::structured_max_pool2d_with_indices_backward { structured_max_pool2d_with_indices_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_max_pool2d_with_indices_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, at::Tensor & grad_input) { structured_max_pool2d_with_indices_backward_meta_out op(grad_input); op.meta(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("max_pool2d_with_indices_backward", TORCH_FN(wrapper_Meta_max_pool2d_with_indices_backward)); m.impl("max_pool2d_with_indices_backward.grad_input", TORCH_FN(wrapper_Meta_max_pool2d_with_indices_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor max_pool2d_with_indices_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices) { return wrapper_Meta_max_pool2d_with_indices_backward(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices); } at::Tensor & max_pool2d_with_indices_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices) { return wrapper_Meta_max_pool2d_with_indices_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices, grad_input); } at::Tensor & max_pool2d_with_indices_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, const at::Tensor & indices, at::Tensor & grad_input) { return wrapper_Meta_max_pool2d_with_indices_backward_out_grad_input(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_reflection_pad1d_meta_functional final : public at::meta::structured_reflection_pad1d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_reflection_pad1d(const at::Tensor & self, at::IntArrayRef padding) { structured_reflection_pad1d_meta_functional op; op.meta(self, padding); return std::move(op.outputs_[0]); } struct structured_reflection_pad1d_meta_out final : public at::meta::structured_reflection_pad1d { structured_reflection_pad1d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reflection_pad1d_out_out(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { structured_reflection_pad1d_meta_out op(out); op.meta(self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("reflection_pad1d", TORCH_FN(wrapper_Meta_reflection_pad1d)); m.impl("reflection_pad1d.out", TORCH_FN(wrapper_Meta_reflection_pad1d_out_out)); } } // anonymous namespace namespace meta { at::Tensor reflection_pad1d(const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad1d(self, padding); } at::Tensor reflection_pad1d_symint(const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad1d(self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & reflection_pad1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad1d_out_out(self, padding, out); } at::Tensor & reflection_pad1d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { return wrapper_Meta_reflection_pad1d_out_out(self, padding, out); } at::Tensor & reflection_pad1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad1d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } at::Tensor & reflection_pad1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out) { return wrapper_Meta_reflection_pad1d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_reflection_pad1d_backward_meta_functional final : public at::meta::structured_reflection_pad1d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_reflection_pad1d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { structured_reflection_pad1d_backward_meta_functional op; op.meta(grad_output, self, padding); return std::move(op.outputs_[0]); } struct structured_reflection_pad1d_backward_meta_out final : public at::meta::structured_reflection_pad1d_backward { structured_reflection_pad1d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reflection_pad1d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { structured_reflection_pad1d_backward_meta_out op(grad_input); op.meta(grad_output, self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("reflection_pad1d_backward", TORCH_FN(wrapper_Meta_reflection_pad1d_backward)); m.impl("reflection_pad1d_backward.grad_input", TORCH_FN(wrapper_Meta_reflection_pad1d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor reflection_pad1d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad1d_backward(grad_output, self, padding); } at::Tensor reflection_pad1d_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad1d_backward(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & reflection_pad1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad1d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & reflection_pad1d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_reflection_pad1d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & reflection_pad1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad1d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } at::Tensor & reflection_pad1d_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_reflection_pad1d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_reflection_pad3d_meta_functional final : public at::meta::structured_reflection_pad3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_reflection_pad3d(const at::Tensor & self, at::IntArrayRef padding) { structured_reflection_pad3d_meta_functional op; op.meta(self, padding); return std::move(op.outputs_[0]); } struct structured_reflection_pad3d_meta_out final : public at::meta::structured_reflection_pad3d { structured_reflection_pad3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reflection_pad3d_out_out(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { structured_reflection_pad3d_meta_out op(out); op.meta(self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("reflection_pad3d", TORCH_FN(wrapper_Meta_reflection_pad3d)); m.impl("reflection_pad3d.out", TORCH_FN(wrapper_Meta_reflection_pad3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor reflection_pad3d(const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad3d(self, padding); } at::Tensor reflection_pad3d_symint(const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad3d(self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & reflection_pad3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad3d_out_out(self, padding, out); } at::Tensor & reflection_pad3d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { return wrapper_Meta_reflection_pad3d_out_out(self, padding, out); } at::Tensor & reflection_pad3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad3d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } at::Tensor & reflection_pad3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out) { return wrapper_Meta_reflection_pad3d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_reflection_pad3d_backward_meta_functional final : public at::meta::structured_reflection_pad3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_reflection_pad3d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { structured_reflection_pad3d_backward_meta_functional op; op.meta(grad_output, self, padding); return std::move(op.outputs_[0]); } struct structured_reflection_pad3d_backward_meta_out final : public at::meta::structured_reflection_pad3d_backward { structured_reflection_pad3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_reflection_pad3d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { structured_reflection_pad3d_backward_meta_out op(grad_input); op.meta(grad_output, self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("reflection_pad3d_backward", TORCH_FN(wrapper_Meta_reflection_pad3d_backward)); m.impl("reflection_pad3d_backward.grad_input", TORCH_FN(wrapper_Meta_reflection_pad3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor reflection_pad3d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad3d_backward(grad_output, self, padding); } at::Tensor reflection_pad3d_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad3d_backward(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & reflection_pad3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_reflection_pad3d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & reflection_pad3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_reflection_pad3d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & reflection_pad3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_reflection_pad3d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } at::Tensor & reflection_pad3d_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_reflection_pad3d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_replication_pad1d_meta_functional final : public at::meta::structured_replication_pad1d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_replication_pad1d(const at::Tensor & self, at::IntArrayRef padding) { structured_replication_pad1d_meta_functional op; op.meta(self, padding); return std::move(op.outputs_[0]); } struct structured_replication_pad1d_meta_out final : public at::meta::structured_replication_pad1d { structured_replication_pad1d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_replication_pad1d_out_out(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { structured_replication_pad1d_meta_out op(out); op.meta(self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("replication_pad1d", TORCH_FN(wrapper_Meta_replication_pad1d)); m.impl("replication_pad1d.out", TORCH_FN(wrapper_Meta_replication_pad1d_out_out)); } } // anonymous namespace namespace meta { at::Tensor replication_pad1d(const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad1d(self, padding); } at::Tensor replication_pad1d_symint(const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad1d(self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & replication_pad1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad1d_out_out(self, padding, out); } at::Tensor & replication_pad1d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad1d_out_out(self, padding, out); } at::Tensor & replication_pad1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad1d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } at::Tensor & replication_pad1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad1d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_replication_pad1d_backward_meta_functional final : public at::meta::structured_replication_pad1d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_replication_pad1d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { structured_replication_pad1d_backward_meta_functional op; op.meta(grad_output, self, padding); return std::move(op.outputs_[0]); } struct structured_replication_pad1d_backward_meta_out final : public at::meta::structured_replication_pad1d_backward { structured_replication_pad1d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_replication_pad1d_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { structured_replication_pad1d_backward_meta_out op(grad_input); op.meta(grad_output, self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("replication_pad1d_backward", TORCH_FN(wrapper_Meta_replication_pad1d_backward)); m.impl("replication_pad1d_backward.grad_input", TORCH_FN(wrapper_Meta_replication_pad1d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor replication_pad1d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad1d_backward(grad_output, self, padding); } at::Tensor replication_pad1d_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad1d_backward(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & replication_pad1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad1d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & replication_pad1d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_replication_pad1d_backward_out_grad_input(grad_output, self, padding, grad_input); } at::Tensor & replication_pad1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad1d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } at::Tensor & replication_pad1d_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & grad_input) { return wrapper_Meta_replication_pad1d_backward_out_grad_input(grad_output, self, C10_AS_INTARRAYREF_SLOW(padding), grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_replication_pad2d_meta_functional final : public at::meta::structured_replication_pad2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_replication_pad2d(const at::Tensor & self, at::IntArrayRef padding) { structured_replication_pad2d_meta_functional op; op.meta(self, padding); return std::move(op.outputs_[0]); } struct structured_replication_pad2d_meta_out final : public at::meta::structured_replication_pad2d { structured_replication_pad2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_replication_pad2d_out_out(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { structured_replication_pad2d_meta_out op(out); op.meta(self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("replication_pad2d", TORCH_FN(wrapper_Meta_replication_pad2d)); m.impl("replication_pad2d.out", TORCH_FN(wrapper_Meta_replication_pad2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor replication_pad2d(const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad2d(self, padding); } at::Tensor replication_pad2d_symint(const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad2d(self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & replication_pad2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad2d_out_out(self, padding, out); } at::Tensor & replication_pad2d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad2d_out_out(self, padding, out); } at::Tensor & replication_pad2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad2d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } at::Tensor & replication_pad2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad2d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_replication_pad3d_meta_functional final : public at::meta::structured_replication_pad3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_replication_pad3d(const at::Tensor & self, at::IntArrayRef padding) { structured_replication_pad3d_meta_functional op; op.meta(self, padding); return std::move(op.outputs_[0]); } struct structured_replication_pad3d_meta_out final : public at::meta::structured_replication_pad3d { structured_replication_pad3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_replication_pad3d_out_out(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { structured_replication_pad3d_meta_out op(out); op.meta(self, padding); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("replication_pad3d", TORCH_FN(wrapper_Meta_replication_pad3d)); m.impl("replication_pad3d.out", TORCH_FN(wrapper_Meta_replication_pad3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor replication_pad3d(const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad3d(self, padding); } at::Tensor replication_pad3d_symint(const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad3d(self, C10_AS_INTARRAYREF_SLOW(padding)); } at::Tensor & replication_pad3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding) { return wrapper_Meta_replication_pad3d_out_out(self, padding, out); } at::Tensor & replication_pad3d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad3d_out_out(self, padding, out); } at::Tensor & replication_pad3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding) { return wrapper_Meta_replication_pad3d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } at::Tensor & replication_pad3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out) { return wrapper_Meta_replication_pad3d_out_out(self, C10_AS_INTARRAYREF_SLOW(padding), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_linear1d_meta_functional final : public at::meta::structured_upsample_linear1d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_linear1d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales) { structured_upsample_linear1d_meta_functional op; op.meta(self, output_size, align_corners, scales); return std::move(op.outputs_[0]); } struct structured_upsample_linear1d_meta_out final : public at::meta::structured_upsample_linear1d { structured_upsample_linear1d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_linear1d_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales, at::Tensor & out) { structured_upsample_linear1d_meta_out op(out); op.meta(self, output_size, align_corners, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_linear1d", TORCH_FN(wrapper_Meta_upsample_linear1d)); m.impl("upsample_linear1d.out", TORCH_FN(wrapper_Meta_upsample_linear1d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_linear1d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d(self, output_size, align_corners, scales); } at::Tensor upsample_linear1d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales); } at::Tensor & upsample_linear1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_out_out(self, output_size, align_corners, scales, out); } at::Tensor & upsample_linear1d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales, at::Tensor & out) { return wrapper_Meta_upsample_linear1d_out_out(self, output_size, align_corners, scales, out); } at::Tensor & upsample_linear1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales, out); } at::Tensor & upsample_linear1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales, at::Tensor & out) { return wrapper_Meta_upsample_linear1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_linear1d_backward_meta_functional final : public at::meta::structured_upsample_linear1d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_linear1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales) { structured_upsample_linear1d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales); return std::move(op.outputs_[0]); } struct structured_upsample_linear1d_backward_meta_out final : public at::meta::structured_upsample_linear1d_backward { structured_upsample_linear1d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_linear1d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales, at::Tensor & grad_input) { structured_upsample_linear1d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_linear1d_backward", TORCH_FN(wrapper_Meta_upsample_linear1d_backward)); m.impl("upsample_linear1d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_linear1d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_linear1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_backward(grad_output, output_size, input_size, align_corners, scales); } at::Tensor upsample_linear1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales); } at::Tensor & upsample_linear1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales, grad_input); } at::Tensor & upsample_linear1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta_upsample_linear1d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales, grad_input); } at::Tensor & upsample_linear1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales) { return wrapper_Meta_upsample_linear1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales, grad_input); } at::Tensor & upsample_linear1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta_upsample_linear1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_bilinear2d_meta_functional final : public at::meta::structured_upsample_bilinear2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_bilinear2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_bilinear2d_meta_functional op; op.meta(self, output_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_bilinear2d_meta_out final : public at::meta::structured_upsample_bilinear2d { structured_upsample_bilinear2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_bilinear2d_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured_upsample_bilinear2d_meta_out op(out); op.meta(self, output_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_bilinear2d", TORCH_FN(wrapper_Meta_upsample_bilinear2d)); m.impl("upsample_bilinear2d.out", TORCH_FN(wrapper_Meta_upsample_bilinear2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_bilinear2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d(self, output_size, align_corners, scales_h, scales_w); } at::Tensor upsample_bilinear2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w); } at::Tensor & upsample_bilinear2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bilinear2d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_bilinear2d_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bilinear2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bilinear2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_bilinear2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_bilinear2d_backward_meta_functional final : public at::meta::structured_upsample_bilinear2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_bilinear2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_bilinear2d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_bilinear2d_backward_meta_out final : public at::meta::structured_upsample_bilinear2d_backward { structured_upsample_bilinear2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_bilinear2d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured_upsample_bilinear2d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_bilinear2d_backward", TORCH_FN(wrapper_Meta_upsample_bilinear2d_backward)); m.impl("upsample_bilinear2d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_bilinear2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_bilinear2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w); } at::Tensor upsample_bilinear2d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w); } at::Tensor & upsample_bilinear2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bilinear2d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_bilinear2d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bilinear2d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bilinear2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bilinear2d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_bilinear2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_bilinear2d_aa_meta_functional final : public at::meta::structured__upsample_bilinear2d_aa { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_bilinear2d_aa(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_bilinear2d_aa_meta_functional op; op.meta(self, output_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_bilinear2d_aa_meta_out final : public at::meta::structured__upsample_bilinear2d_aa { structured__upsample_bilinear2d_aa_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_bilinear2d_aa_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured__upsample_bilinear2d_aa_meta_out op(out); op.meta(self, output_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_bilinear2d_aa", TORCH_FN(wrapper_Meta__upsample_bilinear2d_aa)); m.impl("_upsample_bilinear2d_aa.out", TORCH_FN(wrapper_Meta__upsample_bilinear2d_aa_out_out)); } } // anonymous namespace namespace meta { at::Tensor _upsample_bilinear2d_aa(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa(self, output_size, align_corners, scales_h, scales_w); } at::Tensor _upsample_bilinear2d_aa_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w); } at::Tensor & _upsample_bilinear2d_aa_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bilinear2d_aa_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_bilinear2d_aa_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bilinear2d_aa_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bilinear2d_aa_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_bilinear2d_aa_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_bilinear2d_aa_backward_meta_functional final : public at::meta::structured__upsample_bilinear2d_aa_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_bilinear2d_aa_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_bilinear2d_aa_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_bilinear2d_aa_backward_meta_out final : public at::meta::structured__upsample_bilinear2d_aa_backward { structured__upsample_bilinear2d_aa_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured__upsample_bilinear2d_aa_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_bilinear2d_aa_backward", TORCH_FN(wrapper_Meta__upsample_bilinear2d_aa_backward)); m.impl("_upsample_bilinear2d_aa_backward.grad_input", TORCH_FN(wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor _upsample_bilinear2d_aa_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w); } at::Tensor _upsample_bilinear2d_aa_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w); } at::Tensor & _upsample_bilinear2d_aa_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bilinear2d_aa_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bilinear2d_aa_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bilinear2d_aa_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_bilinear2d_aa_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_bicubic2d_meta_functional final : public at::meta::structured_upsample_bicubic2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_bicubic2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_bicubic2d_meta_functional op; op.meta(self, output_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_bicubic2d_meta_out final : public at::meta::structured_upsample_bicubic2d { structured_upsample_bicubic2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_bicubic2d_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured_upsample_bicubic2d_meta_out op(out); op.meta(self, output_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_bicubic2d", TORCH_FN(wrapper_Meta_upsample_bicubic2d)); m.impl("upsample_bicubic2d.out", TORCH_FN(wrapper_Meta_upsample_bicubic2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_bicubic2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d(self, output_size, align_corners, scales_h, scales_w); } at::Tensor upsample_bicubic2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w); } at::Tensor & upsample_bicubic2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bicubic2d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_bicubic2d_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bicubic2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } at::Tensor & upsample_bicubic2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_bicubic2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_bicubic2d_backward_meta_functional final : public at::meta::structured_upsample_bicubic2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_bicubic2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_bicubic2d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_bicubic2d_backward_meta_out final : public at::meta::structured_upsample_bicubic2d_backward { structured_upsample_bicubic2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_bicubic2d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured_upsample_bicubic2d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_bicubic2d_backward", TORCH_FN(wrapper_Meta_upsample_bicubic2d_backward)); m.impl("upsample_bicubic2d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_bicubic2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_bicubic2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w); } at::Tensor upsample_bicubic2d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w); } at::Tensor & upsample_bicubic2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bicubic2d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_bicubic2d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bicubic2d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_bicubic2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } at::Tensor & upsample_bicubic2d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_bicubic2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_bicubic2d_aa_meta_functional final : public at::meta::structured__upsample_bicubic2d_aa { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_bicubic2d_aa(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_bicubic2d_aa_meta_functional op; op.meta(self, output_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_bicubic2d_aa_meta_out final : public at::meta::structured__upsample_bicubic2d_aa { structured__upsample_bicubic2d_aa_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_bicubic2d_aa_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured__upsample_bicubic2d_aa_meta_out op(out); op.meta(self, output_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_bicubic2d_aa", TORCH_FN(wrapper_Meta__upsample_bicubic2d_aa)); m.impl("_upsample_bicubic2d_aa.out", TORCH_FN(wrapper_Meta__upsample_bicubic2d_aa_out_out)); } } // anonymous namespace namespace meta { at::Tensor _upsample_bicubic2d_aa(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa(self, output_size, align_corners, scales_h, scales_w); } at::Tensor _upsample_bicubic2d_aa_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w); } at::Tensor & _upsample_bicubic2d_aa_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bicubic2d_aa_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_bicubic2d_aa_out_out(self, output_size, align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bicubic2d_aa_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } at::Tensor & _upsample_bicubic2d_aa_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_bicubic2d_aa_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_bicubic2d_aa_backward_meta_functional final : public at::meta::structured__upsample_bicubic2d_aa_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_bicubic2d_aa_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_bicubic2d_aa_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_bicubic2d_aa_backward_meta_out final : public at::meta::structured__upsample_bicubic2d_aa_backward { structured__upsample_bicubic2d_aa_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured__upsample_bicubic2d_aa_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_bicubic2d_aa_backward", TORCH_FN(wrapper_Meta__upsample_bicubic2d_aa_backward)); m.impl("_upsample_bicubic2d_aa_backward.grad_input", TORCH_FN(wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor _upsample_bicubic2d_aa_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_backward(grad_output, output_size, input_size, align_corners, scales_h, scales_w); } at::Tensor _upsample_bicubic2d_aa_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w); } at::Tensor & _upsample_bicubic2d_aa_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bicubic2d_aa_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bicubic2d_aa_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } at::Tensor & _upsample_bicubic2d_aa_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_bicubic2d_aa_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_trilinear3d_meta_functional final : public at::meta::structured_upsample_trilinear3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_trilinear3d_meta_functional op; op.meta(self, output_size, align_corners, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_trilinear3d_meta_out final : public at::meta::structured_upsample_trilinear3d { structured_upsample_trilinear3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_trilinear3d_out_out(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured_upsample_trilinear3d_meta_out op(out); op.meta(self, output_size, align_corners, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_trilinear3d", TORCH_FN(wrapper_Meta_upsample_trilinear3d)); m.impl("upsample_trilinear3d.out", TORCH_FN(wrapper_Meta_upsample_trilinear3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d(self, output_size, align_corners, scales_d, scales_h, scales_w); } at::Tensor upsample_trilinear3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_d, scales_h, scales_w); } at::Tensor & upsample_trilinear3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_out_out(self, output_size, align_corners, scales_d, scales_h, scales_w, out); } at::Tensor & upsample_trilinear3d_outf(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_trilinear3d_out_out(self, output_size, align_corners, scales_d, scales_h, scales_w, out); } at::Tensor & upsample_trilinear3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_d, scales_h, scales_w, out); } at::Tensor & upsample_trilinear3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_trilinear3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), align_corners, scales_d, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_trilinear3d_backward_meta_functional final : public at::meta::structured_upsample_trilinear3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_trilinear3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_trilinear3d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_trilinear3d_backward_meta_out final : public at::meta::structured_upsample_trilinear3d_backward { structured_upsample_trilinear3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_trilinear3d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured_upsample_trilinear3d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_trilinear3d_backward", TORCH_FN(wrapper_Meta_upsample_trilinear3d_backward)); m.impl("upsample_trilinear3d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_trilinear3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_trilinear3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_backward(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w); } at::Tensor upsample_trilinear3d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_d, scales_h, scales_w); } at::Tensor & upsample_trilinear3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_trilinear3d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_trilinear3d_backward_out_grad_input(grad_output, output_size, input_size, align_corners, scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_trilinear3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_trilinear3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_trilinear3d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_trilinear3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), align_corners, scales_d, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest1d_meta_functional final : public at::meta::structured_upsample_nearest1d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest1d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { structured_upsample_nearest1d_meta_functional op; op.meta(self, output_size, scales); return std::move(op.outputs_[0]); } struct structured_upsample_nearest1d_meta_out final : public at::meta::structured_upsample_nearest1d { structured_upsample_nearest1d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest1d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales, at::Tensor & out) { structured_upsample_nearest1d_meta_out op(out); op.meta(self, output_size, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest1d", TORCH_FN(wrapper_Meta_upsample_nearest1d)); m.impl("upsample_nearest1d.out", TORCH_FN(wrapper_Meta_upsample_nearest1d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest1d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d(self, output_size, scales); } at::Tensor upsample_nearest1d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales); } at::Tensor & upsample_nearest1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_out_out(self, output_size, scales, out); } at::Tensor & upsample_nearest1d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales, at::Tensor & out) { return wrapper_Meta_upsample_nearest1d_out_out(self, output_size, scales, out); } at::Tensor & upsample_nearest1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales, out); } at::Tensor & upsample_nearest1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales, at::Tensor & out) { return wrapper_Meta_upsample_nearest1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact1d_meta_functional final : public at::meta::structured__upsample_nearest_exact1d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact1d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { structured__upsample_nearest_exact1d_meta_functional op; op.meta(self, output_size, scales); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact1d_meta_out final : public at::meta::structured__upsample_nearest_exact1d { structured__upsample_nearest_exact1d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact1d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales, at::Tensor & out) { structured__upsample_nearest_exact1d_meta_out op(out); op.meta(self, output_size, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact1d", TORCH_FN(wrapper_Meta__upsample_nearest_exact1d)); m.impl("_upsample_nearest_exact1d.out", TORCH_FN(wrapper_Meta__upsample_nearest_exact1d_out_out)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact1d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d(self, output_size, scales); } at::Tensor _upsample_nearest_exact1d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales); } at::Tensor & _upsample_nearest_exact1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_out_out(self, output_size, scales, out); } at::Tensor & _upsample_nearest_exact1d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact1d_out_out(self, output_size, scales, out); } at::Tensor & _upsample_nearest_exact1d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales, out); } at::Tensor & _upsample_nearest_exact1d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact1d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest1d_backward_meta_functional final : public at::meta::structured_upsample_nearest1d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { structured_upsample_nearest1d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales); return std::move(op.outputs_[0]); } struct structured_upsample_nearest1d_backward_meta_out final : public at::meta::structured_upsample_nearest1d_backward { structured_upsample_nearest1d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest1d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { structured_upsample_nearest1d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest1d_backward", TORCH_FN(wrapper_Meta_upsample_nearest1d_backward)); m.impl("upsample_nearest1d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_nearest1d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_backward(grad_output, output_size, input_size, scales); } at::Tensor upsample_nearest1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales); } at::Tensor & upsample_nearest1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_backward_out_grad_input(grad_output, output_size, input_size, scales, grad_input); } at::Tensor & upsample_nearest1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest1d_backward_out_grad_input(grad_output, output_size, input_size, scales, grad_input); } at::Tensor & upsample_nearest1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales) { return wrapper_Meta_upsample_nearest1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales, grad_input); } at::Tensor & upsample_nearest1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact1d_backward_meta_functional final : public at::meta::structured__upsample_nearest_exact1d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { structured__upsample_nearest_exact1d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact1d_backward_meta_out final : public at::meta::structured__upsample_nearest_exact1d_backward { structured__upsample_nearest_exact1d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { structured__upsample_nearest_exact1d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact1d_backward", TORCH_FN(wrapper_Meta__upsample_nearest_exact1d_backward)); m.impl("_upsample_nearest_exact1d_backward.grad_input", TORCH_FN(wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_backward(grad_output, output_size, input_size, scales); } at::Tensor _upsample_nearest_exact1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales); } at::Tensor & _upsample_nearest_exact1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input(grad_output, output_size, input_size, scales, grad_input); } at::Tensor & _upsample_nearest_exact1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input(grad_output, output_size, input_size, scales, grad_input); } at::Tensor & _upsample_nearest_exact1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales) { return wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales, grad_input); } at::Tensor & _upsample_nearest_exact1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact1d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest2d_meta_functional final : public at::meta::structured_upsample_nearest2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest2d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_nearest2d_meta_functional op; op.meta(self, output_size, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_nearest2d_meta_out final : public at::meta::structured_upsample_nearest2d { structured_upsample_nearest2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest2d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured_upsample_nearest2d_meta_out op(out); op.meta(self, output_size, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest2d", TORCH_FN(wrapper_Meta_upsample_nearest2d)); m.impl("upsample_nearest2d.out", TORCH_FN(wrapper_Meta_upsample_nearest2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest2d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d(self, output_size, scales_h, scales_w); } at::Tensor upsample_nearest2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w); } at::Tensor & upsample_nearest2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_out_out(self, output_size, scales_h, scales_w, out); } at::Tensor & upsample_nearest2d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_nearest2d_out_out(self, output_size, scales_h, scales_w, out); } at::Tensor & upsample_nearest2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w, out); } at::Tensor & upsample_nearest2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_nearest2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact2d_meta_functional final : public at::meta::structured__upsample_nearest_exact2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact2d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_nearest_exact2d_meta_functional op; op.meta(self, output_size, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact2d_meta_out final : public at::meta::structured__upsample_nearest_exact2d { structured__upsample_nearest_exact2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact2d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured__upsample_nearest_exact2d_meta_out op(out); op.meta(self, output_size, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact2d", TORCH_FN(wrapper_Meta__upsample_nearest_exact2d)); m.impl("_upsample_nearest_exact2d.out", TORCH_FN(wrapper_Meta__upsample_nearest_exact2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact2d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d(self, output_size, scales_h, scales_w); } at::Tensor _upsample_nearest_exact2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w); } at::Tensor & _upsample_nearest_exact2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_out_out(self, output_size, scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact2d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact2d_out_out(self, output_size, scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact2d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest2d_backward_meta_functional final : public at::meta::structured_upsample_nearest2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_nearest2d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_nearest2d_backward_meta_out final : public at::meta::structured_upsample_nearest2d_backward { structured_upsample_nearest2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest2d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured_upsample_nearest2d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest2d_backward", TORCH_FN(wrapper_Meta_upsample_nearest2d_backward)); m.impl("upsample_nearest2d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_nearest2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_backward(grad_output, output_size, input_size, scales_h, scales_w); } at::Tensor upsample_nearest2d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w); } at::Tensor & upsample_nearest2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_backward_out_grad_input(grad_output, output_size, input_size, scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest2d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest2d_backward_out_grad_input(grad_output, output_size, input_size, scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest2d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest2d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact2d_backward_meta_functional final : public at::meta::structured__upsample_nearest_exact2d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_nearest_exact2d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact2d_backward_meta_out final : public at::meta::structured__upsample_nearest_exact2d_backward { structured__upsample_nearest_exact2d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured__upsample_nearest_exact2d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact2d_backward", TORCH_FN(wrapper_Meta__upsample_nearest_exact2d_backward)); m.impl("_upsample_nearest_exact2d_backward.grad_input", TORCH_FN(wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_backward(grad_output, output_size, input_size, scales_h, scales_w); } at::Tensor _upsample_nearest_exact2d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w); } at::Tensor & _upsample_nearest_exact2d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input(grad_output, output_size, input_size, scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact2d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input(grad_output, output_size, input_size, scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact2d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact2d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact2d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest3d_meta_functional final : public at::meta::structured_upsample_nearest3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest3d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_nearest3d_meta_functional op; op.meta(self, output_size, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_nearest3d_meta_out final : public at::meta::structured_upsample_nearest3d { structured_upsample_nearest3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest3d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured_upsample_nearest3d_meta_out op(out); op.meta(self, output_size, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest3d", TORCH_FN(wrapper_Meta_upsample_nearest3d)); m.impl("upsample_nearest3d.out", TORCH_FN(wrapper_Meta_upsample_nearest3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest3d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d(self, output_size, scales_d, scales_h, scales_w); } at::Tensor upsample_nearest3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w); } at::Tensor & upsample_nearest3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_out_out(self, output_size, scales_d, scales_h, scales_w, out); } at::Tensor & upsample_nearest3d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_nearest3d_out_out(self, output_size, scales_d, scales_h, scales_w, out); } at::Tensor & upsample_nearest3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w, out); } at::Tensor & upsample_nearest3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta_upsample_nearest3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact3d_meta_functional final : public at::meta::structured__upsample_nearest_exact3d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact3d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_nearest_exact3d_meta_functional op; op.meta(self, output_size, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact3d_meta_out final : public at::meta::structured__upsample_nearest_exact3d { structured__upsample_nearest_exact3d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact3d_out_out(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { structured__upsample_nearest_exact3d_meta_out op(out); op.meta(self, output_size, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact3d", TORCH_FN(wrapper_Meta__upsample_nearest_exact3d)); m.impl("_upsample_nearest_exact3d.out", TORCH_FN(wrapper_Meta__upsample_nearest_exact3d_out_out)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact3d(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d(self, output_size, scales_d, scales_h, scales_w); } at::Tensor _upsample_nearest_exact3d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w); } at::Tensor & _upsample_nearest_exact3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_out_out(self, output_size, scales_d, scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact3d_outf(const at::Tensor & self, at::IntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact3d_out_out(self, output_size, scales_d, scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w, out); } at::Tensor & _upsample_nearest_exact3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & out) { return wrapper_Meta__upsample_nearest_exact3d_out_out(self, C10_AS_INTARRAYREF_SLOW(output_size), scales_d, scales_h, scales_w, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_upsample_nearest3d_backward_meta_functional final : public at::meta::structured_upsample_nearest3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_upsample_nearest3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured_upsample_nearest3d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured_upsample_nearest3d_backward_meta_out final : public at::meta::structured_upsample_nearest3d_backward { structured_upsample_nearest3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_upsample_nearest3d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured_upsample_nearest3d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("upsample_nearest3d_backward", TORCH_FN(wrapper_Meta_upsample_nearest3d_backward)); m.impl("upsample_nearest3d_backward.grad_input", TORCH_FN(wrapper_Meta_upsample_nearest3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor upsample_nearest3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_backward(grad_output, output_size, input_size, scales_d, scales_h, scales_w); } at::Tensor upsample_nearest3d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w); } at::Tensor & upsample_nearest3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_backward_out_grad_input(grad_output, output_size, input_size, scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest3d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest3d_backward_out_grad_input(grad_output, output_size, input_size, scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta_upsample_nearest3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w, grad_input); } at::Tensor & upsample_nearest3d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta_upsample_nearest3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__upsample_nearest_exact3d_backward_meta_functional final : public at::meta::structured__upsample_nearest_exact3d_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta__upsample_nearest_exact3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { structured__upsample_nearest_exact3d_backward_meta_functional op; op.meta(grad_output, output_size, input_size, scales_d, scales_h, scales_w); return std::move(op.outputs_[0]); } struct structured__upsample_nearest_exact3d_backward_meta_out final : public at::meta::structured__upsample_nearest_exact3d_backward { structured__upsample_nearest_exact3d_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { structured__upsample_nearest_exact3d_backward_meta_out op(grad_input); op.meta(grad_output, output_size, input_size, scales_d, scales_h, scales_w); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_upsample_nearest_exact3d_backward", TORCH_FN(wrapper_Meta__upsample_nearest_exact3d_backward)); m.impl("_upsample_nearest_exact3d_backward.grad_input", TORCH_FN(wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor _upsample_nearest_exact3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_backward(grad_output, output_size, input_size, scales_d, scales_h, scales_w); } at::Tensor _upsample_nearest_exact3d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_backward(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w); } at::Tensor & _upsample_nearest_exact3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input(grad_output, output_size, input_size, scales_d, scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact3d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input(grad_output, output_size, input_size, scales_d, scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w) { return wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w, grad_input); } at::Tensor & _upsample_nearest_exact3d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, ::std::optional scales_d, ::std::optional scales_h, ::std::optional scales_w, at::Tensor & grad_input) { return wrapper_Meta__upsample_nearest_exact3d_backward_out_grad_input(grad_output, C10_AS_INTARRAYREF_SLOW(output_size), C10_AS_INTARRAYREF_SLOW(input_size), scales_d, scales_h, scales_w, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_sigmoid_backward_meta_functional final : public at::meta::structured_sigmoid_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_sigmoid_backward(const at::Tensor & grad_output, const at::Tensor & output) { structured_sigmoid_backward_meta_functional op; op.meta(grad_output, output); return std::move(op.outputs_[0]); } struct structured_sigmoid_backward_meta_out final : public at::meta::structured_sigmoid_backward { structured_sigmoid_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_sigmoid_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_sigmoid_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & output, at::Tensor & grad_input) { structured_sigmoid_backward_meta_out op(grad_input); op.meta(grad_output, output); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("sigmoid_backward", TORCH_FN(wrapper_Meta_sigmoid_backward)); m.impl("sigmoid_backward.grad_input", TORCH_FN(wrapper_Meta_sigmoid_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor sigmoid_backward(const at::Tensor & grad_output, const at::Tensor & output) { return wrapper_Meta_sigmoid_backward(grad_output, output); } at::Tensor & sigmoid_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & output) { return wrapper_Meta_sigmoid_backward_out_grad_input(grad_output, output, grad_input); } at::Tensor & sigmoid_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, at::Tensor & grad_input) { return wrapper_Meta_sigmoid_backward_out_grad_input(grad_output, output, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_logit_backward_meta_functional final : public at::meta::structured_logit_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logit_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logit_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_logit_backward(const at::Tensor & grad_output, const at::Tensor & self, ::std::optional eps) { structured_logit_backward_meta_functional op; op.meta(grad_output, self, eps); return std::move(op.outputs_[0]); } struct structured_logit_backward_meta_out final : public at::meta::structured_logit_backward { structured_logit_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logit_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_logit_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_logit_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & self, ::std::optional eps, at::Tensor & grad_input) { structured_logit_backward_meta_out op(grad_input); op.meta(grad_output, self, eps); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("logit_backward", TORCH_FN(wrapper_Meta_logit_backward)); m.impl("logit_backward.grad_input", TORCH_FN(wrapper_Meta_logit_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor logit_backward(const at::Tensor & grad_output, const at::Tensor & self, ::std::optional eps) { return wrapper_Meta_logit_backward(grad_output, self, eps); } at::Tensor & logit_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, ::std::optional eps) { return wrapper_Meta_logit_backward_out_grad_input(grad_output, self, eps, grad_input); } at::Tensor & logit_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, ::std::optional eps, at::Tensor & grad_input) { return wrapper_Meta_logit_backward_out_grad_input(grad_output, self, eps, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_tanh_backward_meta_functional final : public at::meta::structured_tanh_backward { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_tanh_backward(const at::Tensor & grad_output, const at::Tensor & output) { structured_tanh_backward_meta_functional op; op.meta(grad_output, output); return std::move(op.outputs_[0]); } struct structured_tanh_backward_meta_out final : public at::meta::structured_tanh_backward { structured_tanh_backward_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_tanh_backward::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_tanh_backward_out_grad_input(const at::Tensor & grad_output, const at::Tensor & output, at::Tensor & grad_input) { structured_tanh_backward_meta_out op(grad_input); op.meta(grad_output, output); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return grad_input; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("tanh_backward", TORCH_FN(wrapper_Meta_tanh_backward)); m.impl("tanh_backward.grad_input", TORCH_FN(wrapper_Meta_tanh_backward_out_grad_input)); } } // anonymous namespace namespace meta { at::Tensor tanh_backward(const at::Tensor & grad_output, const at::Tensor & output) { return wrapper_Meta_tanh_backward(grad_output, output); } at::Tensor & tanh_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & output) { return wrapper_Meta_tanh_backward_out_grad_input(grad_output, output, grad_input); } at::Tensor & tanh_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, at::Tensor & grad_input) { return wrapper_Meta_tanh_backward_out_grad_input(grad_output, output, grad_input); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_slow_conv_transpose2d_meta_functional final : public at::meta::structured_slow_conv_transpose2d { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation) { structured_slow_conv_transpose2d_meta_functional op; op.meta(self, weight, kernel_size, ((bias.has_value() && (*bias).defined()) ? at::OptionalTensorRef(*bias) : at::OptionalTensorRef()), stride, padding, output_padding, dilation); return std::move(op.outputs_[0]); } struct structured_slow_conv_transpose2d_meta_out final : public at::meta::structured_slow_conv_transpose2d { structured_slow_conv_transpose2d_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_slow_conv_transpose2d_out_out(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) { structured_slow_conv_transpose2d_meta_out op(out); op.meta(self, weight, kernel_size, ((bias.has_value() && (*bias).defined()) ? at::OptionalTensorRef(*bias) : at::OptionalTensorRef()), stride, padding, output_padding, dilation); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("slow_conv_transpose2d", TORCH_FN(wrapper_Meta_slow_conv_transpose2d)); m.impl("slow_conv_transpose2d.out", TORCH_FN(wrapper_Meta_slow_conv_transpose2d_out_out)); } } // anonymous namespace namespace meta { at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation) { return wrapper_Meta_slow_conv_transpose2d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation); } at::Tensor slow_conv_transpose2d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation) { return wrapper_Meta_slow_conv_transpose2d(self, weight, C10_AS_INTARRAYREF_SLOW(kernel_size), bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(output_padding), C10_AS_INTARRAYREF_SLOW(dilation)); } at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation) { return wrapper_Meta_slow_conv_transpose2d_out_out(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); } at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) { return wrapper_Meta_slow_conv_transpose2d_out_out(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); } at::Tensor & slow_conv_transpose2d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation) { return wrapper_Meta_slow_conv_transpose2d_out_out(self, weight, C10_AS_INTARRAYREF_SLOW(kernel_size), bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(output_padding), C10_AS_INTARRAYREF_SLOW(dilation), out); } at::Tensor & slow_conv_transpose2d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation, at::Tensor & out) { return wrapper_Meta_slow_conv_transpose2d_out_out(self, weight, C10_AS_INTARRAYREF_SLOW(kernel_size), bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(output_padding), C10_AS_INTARRAYREF_SLOW(dilation), out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_isposinf_meta_functional final : public at::meta::structured_isposinf { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isposinf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isposinf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_isposinf(const at::Tensor & self) { structured_isposinf_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_isposinf_meta_out final : public at::meta::structured_isposinf { structured_isposinf_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isposinf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isposinf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_isposinf_out_out(const at::Tensor & self, at::Tensor & out) { structured_isposinf_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("isposinf", TORCH_FN(wrapper_Meta_isposinf)); m.impl("isposinf.out", TORCH_FN(wrapper_Meta_isposinf_out_out)); } } // anonymous namespace namespace meta { at::Tensor isposinf(const at::Tensor & self) { return wrapper_Meta_isposinf(self); } at::Tensor & isposinf_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_isposinf_out_out(self, out); } at::Tensor & isposinf_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_isposinf_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_isneginf_meta_functional final : public at::meta::structured_isneginf { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isneginf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isneginf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_isneginf(const at::Tensor & self) { structured_isneginf_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_isneginf_meta_out final : public at::meta::structured_isneginf { structured_isneginf_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isneginf::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_isneginf::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_isneginf_out_out(const at::Tensor & self, at::Tensor & out) { structured_isneginf_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("isneginf", TORCH_FN(wrapper_Meta_isneginf)); m.impl("isneginf.out", TORCH_FN(wrapper_Meta_isneginf_out_out)); } } // anonymous namespace namespace meta { at::Tensor isneginf(const at::Tensor & self) { return wrapper_Meta_isneginf(self); } at::Tensor & isneginf_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_isneginf_out_out(self, out); } at::Tensor & isneginf_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_isneginf_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_entr_meta_functional final : public at::meta::structured_special_entr { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_entr::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_entr::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_entr(const at::Tensor & self) { structured_special_entr_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_entr_meta_out final : public at::meta::structured_special_entr { structured_special_entr_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_entr::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_entr::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_entr_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_entr_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_entr", TORCH_FN(wrapper_Meta_special_entr)); m.impl("special_entr.out", TORCH_FN(wrapper_Meta_special_entr_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_entr(const at::Tensor & self) { return wrapper_Meta_special_entr(self); } at::Tensor & special_entr_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_entr_out_out(self, out); } at::Tensor & special_entr_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_entr_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_ndtri_meta_functional final : public at::meta::structured_special_ndtri { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_ndtri::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_ndtri::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_ndtri(const at::Tensor & self) { structured_special_ndtri_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_ndtri_meta_out final : public at::meta::structured_special_ndtri { structured_special_ndtri_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_ndtri::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_ndtri::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_ndtri_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_ndtri_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_ndtri", TORCH_FN(wrapper_Meta_special_ndtri)); m.impl("special_ndtri.out", TORCH_FN(wrapper_Meta_special_ndtri_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_ndtri(const at::Tensor & self) { return wrapper_Meta_special_ndtri(self); } at::Tensor & special_ndtri_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_ndtri_out_out(self, out); } at::Tensor & special_ndtri_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_ndtri_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_log_ndtr_meta_functional final : public at::meta::structured_special_log_ndtr { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_log_ndtr::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_log_ndtr::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_log_ndtr(const at::Tensor & self) { structured_special_log_ndtr_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_log_ndtr_meta_out final : public at::meta::structured_special_log_ndtr { structured_special_log_ndtr_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_log_ndtr::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_log_ndtr::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_log_ndtr_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_log_ndtr_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_log_ndtr", TORCH_FN(wrapper_Meta_special_log_ndtr)); m.impl("special_log_ndtr.out", TORCH_FN(wrapper_Meta_special_log_ndtr_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_log_ndtr(const at::Tensor & self) { return wrapper_Meta_special_log_ndtr(self); } at::Tensor & special_log_ndtr_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_log_ndtr_out_out(self, out); } at::Tensor & special_log_ndtr_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_log_ndtr_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_erfcx_meta_functional final : public at::meta::structured_special_erfcx { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_erfcx::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_erfcx::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_erfcx(const at::Tensor & self) { structured_special_erfcx_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_erfcx_meta_out final : public at::meta::structured_special_erfcx { structured_special_erfcx_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_erfcx::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_erfcx::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_erfcx_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_erfcx_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_erfcx", TORCH_FN(wrapper_Meta_special_erfcx)); m.impl("special_erfcx.out", TORCH_FN(wrapper_Meta_special_erfcx_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_erfcx(const at::Tensor & self) { return wrapper_Meta_special_erfcx(self); } at::Tensor & special_erfcx_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_erfcx_out_out(self, out); } at::Tensor & special_erfcx_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_erfcx_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_xlog1py_meta_functional final : public at::meta::structured_special_xlog1py { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_xlog1py::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_xlog1py::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_xlog1py(const at::Tensor & self, const at::Tensor & other) { structured_special_xlog1py_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_special_xlog1py_meta_out final : public at::meta::structured_special_xlog1py { structured_special_xlog1py_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_xlog1py::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_xlog1py::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_xlog1py_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_special_xlog1py_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_xlog1py", TORCH_FN(wrapper_Meta_special_xlog1py)); m.impl("special_xlog1py.out", TORCH_FN(wrapper_Meta_special_xlog1py_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_xlog1py(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_special_xlog1py(self, other); } at::Tensor & special_xlog1py_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_special_xlog1py_out_out(self, other, out); } at::Tensor & special_xlog1py_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_special_xlog1py_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_zeta_meta_functional final : public at::meta::structured_special_zeta { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_zeta::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_zeta::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_zeta(const at::Tensor & self, const at::Tensor & other) { structured_special_zeta_meta_functional op; op.meta(self, other); return std::move(op.outputs_[0]); } struct structured_special_zeta_meta_out final : public at::meta::structured_special_zeta { structured_special_zeta_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_zeta::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_zeta::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_zeta_out_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { structured_special_zeta_meta_out op(out); op.meta(self, other); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_zeta", TORCH_FN(wrapper_Meta_special_zeta)); m.impl("special_zeta.out", TORCH_FN(wrapper_Meta_special_zeta_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_zeta(const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_special_zeta(self, other); } at::Tensor & special_zeta_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { return wrapper_Meta_special_zeta_out_out(self, other, out); } at::Tensor & special_zeta_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { return wrapper_Meta_special_zeta_out_out(self, other, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_i0e_meta_functional final : public at::meta::structured_special_i0e { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i0e::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i0e::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_i0e(const at::Tensor & self) { structured_special_i0e_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_i0e_meta_out final : public at::meta::structured_special_i0e { structured_special_i0e_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i0e::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i0e::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_i0e_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_i0e_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_i0e", TORCH_FN(wrapper_Meta_special_i0e)); m.impl("special_i0e.out", TORCH_FN(wrapper_Meta_special_i0e_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_i0e(const at::Tensor & self) { return wrapper_Meta_special_i0e(self); } at::Tensor & special_i0e_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_i0e_out_out(self, out); } at::Tensor & special_i0e_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_i0e_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_i1_meta_functional final : public at::meta::structured_special_i1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_i1(const at::Tensor & self) { structured_special_i1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_i1_meta_out final : public at::meta::structured_special_i1 { structured_special_i1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_i1_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_i1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_i1", TORCH_FN(wrapper_Meta_special_i1)); m.impl("special_i1.out", TORCH_FN(wrapper_Meta_special_i1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_i1(const at::Tensor & self) { return wrapper_Meta_special_i1(self); } at::Tensor & special_i1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_i1_out_out(self, out); } at::Tensor & special_i1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_i1_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_i1e_meta_functional final : public at::meta::structured_special_i1e { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1e::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1e::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_i1e(const at::Tensor & self) { structured_special_i1e_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_i1e_meta_out final : public at::meta::structured_special_i1e { structured_special_i1e_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1e::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_i1e::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_i1e_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_i1e_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_i1e", TORCH_FN(wrapper_Meta_special_i1e)); m.impl("special_i1e.out", TORCH_FN(wrapper_Meta_special_i1e_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_i1e(const at::Tensor & self) { return wrapper_Meta_special_i1e(self); } at::Tensor & special_i1e_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_i1e_out_out(self, out); } at::Tensor & special_i1e_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_i1e_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_cholesky_ex_meta_functional final : public at::meta::structured_linalg_cholesky_ex { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_cholesky_ex(const at::Tensor & self, bool upper, bool check_errors) { structured_linalg_cholesky_ex_meta_functional op; op.meta(self, upper, check_errors); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_linalg_cholesky_ex_meta_out final : public at::meta::structured_linalg_cholesky_ex { structured_linalg_cholesky_ex_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_cholesky_ex_out_L(const at::Tensor & self, bool upper, bool check_errors, at::Tensor & L, at::Tensor & info) { structured_linalg_cholesky_ex_meta_out op(L, info); op.meta(self, upper, check_errors); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(L, info); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_cholesky_ex", TORCH_FN(wrapper_Meta_linalg_cholesky_ex)); m.impl("linalg_cholesky_ex.L", TORCH_FN(wrapper_Meta_linalg_cholesky_ex_out_L)); } } // anonymous namespace namespace meta { ::std::tuple linalg_cholesky_ex(const at::Tensor & self, bool upper, bool check_errors) { return wrapper_Meta_linalg_cholesky_ex(self, upper, check_errors); } ::std::tuple linalg_cholesky_ex_out(at::Tensor & L, at::Tensor & info, const at::Tensor & self, bool upper, bool check_errors) { return wrapper_Meta_linalg_cholesky_ex_out_L(self, upper, check_errors, L, info); } ::std::tuple linalg_cholesky_ex_outf(const at::Tensor & self, bool upper, bool check_errors, at::Tensor & L, at::Tensor & info) { return wrapper_Meta_linalg_cholesky_ex_out_L(self, upper, check_errors, L, info); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_cross_meta_functional final : public at::meta::structured_linalg_cross { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_linalg_cross(const at::Tensor & self, const at::Tensor & other, int64_t dim) { structured_linalg_cross_meta_functional op; op.meta(self, other, dim); return std::move(op.outputs_[0]); } struct structured_linalg_cross_meta_out final : public at::meta::structured_linalg_cross { structured_linalg_cross_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_linalg_cross_out_out(const at::Tensor & self, const at::Tensor & other, int64_t dim, at::Tensor & out) { structured_linalg_cross_meta_out op(out); op.meta(self, other, dim); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_cross", TORCH_FN(wrapper_Meta_linalg_cross)); m.impl("linalg_cross.out", TORCH_FN(wrapper_Meta_linalg_cross_out_out)); } } // anonymous namespace namespace meta { at::Tensor linalg_cross(const at::Tensor & self, const at::Tensor & other, int64_t dim) { return wrapper_Meta_linalg_cross(self, other, dim); } at::Tensor & linalg_cross_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, int64_t dim) { return wrapper_Meta_linalg_cross_out_out(self, other, dim, out); } at::Tensor & linalg_cross_outf(const at::Tensor & self, const at::Tensor & other, int64_t dim, at::Tensor & out) { return wrapper_Meta_linalg_cross_out_out(self, other, dim, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_lu_factor_ex_meta_functional final : public at::meta::structured_linalg_lu_factor_ex { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_lu_factor_ex(const at::Tensor & A, bool pivot, bool check_errors) { structured_linalg_lu_factor_ex_meta_functional op; op.meta(A, pivot, check_errors); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured_linalg_lu_factor_ex_meta_out final : public at::meta::structured_linalg_lu_factor_ex { structured_linalg_lu_factor_ex_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_lu_factor_ex_out_out(const at::Tensor & A, bool pivot, bool check_errors, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info) { structured_linalg_lu_factor_ex_meta_out op(LU, pivots, info); op.meta(A, pivot, check_errors); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(LU, pivots, info); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_lu_factor_ex", TORCH_FN(wrapper_Meta_linalg_lu_factor_ex)); m.impl("linalg_lu_factor_ex.out", TORCH_FN(wrapper_Meta_linalg_lu_factor_ex_out_out)); } } // anonymous namespace namespace meta { ::std::tuple linalg_lu_factor_ex(const at::Tensor & A, bool pivot, bool check_errors) { return wrapper_Meta_linalg_lu_factor_ex(A, pivot, check_errors); } ::std::tuple linalg_lu_factor_ex_out(at::Tensor & LU, at::Tensor & pivots, at::Tensor & info, const at::Tensor & A, bool pivot, bool check_errors) { return wrapper_Meta_linalg_lu_factor_ex_out_out(A, pivot, check_errors, LU, pivots, info); } ::std::tuple linalg_lu_factor_ex_outf(const at::Tensor & A, bool pivot, bool check_errors, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info) { return wrapper_Meta_linalg_lu_factor_ex_out_out(A, pivot, check_errors, LU, pivots, info); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_lu_meta_functional final : public at::meta::structured_linalg_lu { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_lu(const at::Tensor & A, bool pivot) { structured_linalg_lu_meta_functional op; op.meta(A, pivot); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured_linalg_lu_meta_out final : public at::meta::structured_linalg_lu { structured_linalg_lu_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_lu_out_out(const at::Tensor & A, bool pivot, at::Tensor & P, at::Tensor & L, at::Tensor & U) { structured_linalg_lu_meta_out op(P, L, U); op.meta(A, pivot); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(P, L, U); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_lu", TORCH_FN(wrapper_Meta_linalg_lu)); m.impl("linalg_lu.out", TORCH_FN(wrapper_Meta_linalg_lu_out_out)); } } // anonymous namespace namespace meta { ::std::tuple linalg_lu(const at::Tensor & A, bool pivot) { return wrapper_Meta_linalg_lu(A, pivot); } ::std::tuple linalg_lu_out(at::Tensor & P, at::Tensor & L, at::Tensor & U, const at::Tensor & A, bool pivot) { return wrapper_Meta_linalg_lu_out_out(A, pivot, P, L, U); } ::std::tuple linalg_lu_outf(const at::Tensor & A, bool pivot, at::Tensor & P, at::Tensor & L, at::Tensor & U) { return wrapper_Meta_linalg_lu_out_out(A, pivot, P, L, U); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_lu_solve_meta_functional final : public at::meta::structured_linalg_lu_solve { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_linalg_lu_solve(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint) { structured_linalg_lu_solve_meta_functional op; op.meta(LU, pivots, B, left, adjoint); return std::move(op.outputs_[0]); } struct structured_linalg_lu_solve_meta_out final : public at::meta::structured_linalg_lu_solve { structured_linalg_lu_solve_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_linalg_lu_solve_out_out(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint, at::Tensor & out) { structured_linalg_lu_solve_meta_out op(out); op.meta(LU, pivots, B, left, adjoint); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_lu_solve", TORCH_FN(wrapper_Meta_linalg_lu_solve)); m.impl("linalg_lu_solve.out", TORCH_FN(wrapper_Meta_linalg_lu_solve_out_out)); } } // anonymous namespace namespace meta { at::Tensor linalg_lu_solve(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint) { return wrapper_Meta_linalg_lu_solve(LU, pivots, B, left, adjoint); } at::Tensor & linalg_lu_solve_out(at::Tensor & out, const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint) { return wrapper_Meta_linalg_lu_solve_out_out(LU, pivots, B, left, adjoint, out); } at::Tensor & linalg_lu_solve_outf(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint, at::Tensor & out) { return wrapper_Meta_linalg_lu_solve_out_out(LU, pivots, B, left, adjoint, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__linalg_det_meta_functional final : public at::meta::structured__linalg_det { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta__linalg_det(const at::Tensor & A) { structured__linalg_det_meta_functional op; op.meta(A); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured__linalg_det_meta_out final : public at::meta::structured__linalg_det { structured__linalg_det_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta__linalg_det_out_result(const at::Tensor & A, at::Tensor & result, at::Tensor & LU, at::Tensor & pivots) { structured__linalg_det_meta_out op(result, LU, pivots); op.meta(A); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(result, LU, pivots); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_linalg_det", TORCH_FN(wrapper_Meta__linalg_det)); m.impl("_linalg_det.result", TORCH_FN(wrapper_Meta__linalg_det_out_result)); } } // anonymous namespace namespace meta { ::std::tuple _linalg_det(const at::Tensor & A) { return wrapper_Meta__linalg_det(A); } ::std::tuple _linalg_det_out(at::Tensor & result, at::Tensor & LU, at::Tensor & pivots, const at::Tensor & A) { return wrapper_Meta__linalg_det_out_result(A, result, LU, pivots); } ::std::tuple _linalg_det_outf(const at::Tensor & A, at::Tensor & result, at::Tensor & LU, at::Tensor & pivots) { return wrapper_Meta__linalg_det_out_result(A, result, LU, pivots); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_ldl_factor_ex_meta_functional final : public at::meta::structured_linalg_ldl_factor_ex { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_ldl_factor_ex(const at::Tensor & self, bool hermitian, bool check_errors) { structured_linalg_ldl_factor_ex_meta_functional op; op.meta(self, hermitian, check_errors); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured_linalg_ldl_factor_ex_meta_out final : public at::meta::structured_linalg_ldl_factor_ex { structured_linalg_ldl_factor_ex_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_ldl_factor_ex_out_out(const at::Tensor & self, bool hermitian, bool check_errors, at::Tensor & LD, at::Tensor & pivots, at::Tensor & info) { structured_linalg_ldl_factor_ex_meta_out op(LD, pivots, info); op.meta(self, hermitian, check_errors); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(LD, pivots, info); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_ldl_factor_ex", TORCH_FN(wrapper_Meta_linalg_ldl_factor_ex)); m.impl("linalg_ldl_factor_ex.out", TORCH_FN(wrapper_Meta_linalg_ldl_factor_ex_out_out)); } } // anonymous namespace namespace meta { ::std::tuple linalg_ldl_factor_ex(const at::Tensor & self, bool hermitian, bool check_errors) { return wrapper_Meta_linalg_ldl_factor_ex(self, hermitian, check_errors); } ::std::tuple linalg_ldl_factor_ex_out(at::Tensor & LD, at::Tensor & pivots, at::Tensor & info, const at::Tensor & self, bool hermitian, bool check_errors) { return wrapper_Meta_linalg_ldl_factor_ex_out_out(self, hermitian, check_errors, LD, pivots, info); } ::std::tuple linalg_ldl_factor_ex_outf(const at::Tensor & self, bool hermitian, bool check_errors, at::Tensor & LD, at::Tensor & pivots, at::Tensor & info) { return wrapper_Meta_linalg_ldl_factor_ex_out_out(self, hermitian, check_errors, LD, pivots, info); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_ldl_solve_meta_functional final : public at::meta::structured_linalg_ldl_solve { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_linalg_ldl_solve(const at::Tensor & LD, const at::Tensor & pivots, const at::Tensor & B, bool hermitian) { structured_linalg_ldl_solve_meta_functional op; op.meta(LD, pivots, B, hermitian); return std::move(op.outputs_[0]); } struct structured_linalg_ldl_solve_meta_out final : public at::meta::structured_linalg_ldl_solve { structured_linalg_ldl_solve_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_linalg_ldl_solve_out_out(const at::Tensor & LD, const at::Tensor & pivots, const at::Tensor & B, bool hermitian, at::Tensor & out) { structured_linalg_ldl_solve_meta_out op(out); op.meta(LD, pivots, B, hermitian); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_ldl_solve", TORCH_FN(wrapper_Meta_linalg_ldl_solve)); m.impl("linalg_ldl_solve.out", TORCH_FN(wrapper_Meta_linalg_ldl_solve_out_out)); } } // anonymous namespace namespace meta { at::Tensor linalg_ldl_solve(const at::Tensor & LD, const at::Tensor & pivots, const at::Tensor & B, bool hermitian) { return wrapper_Meta_linalg_ldl_solve(LD, pivots, B, hermitian); } at::Tensor & linalg_ldl_solve_out(at::Tensor & out, const at::Tensor & LD, const at::Tensor & pivots, const at::Tensor & B, bool hermitian) { return wrapper_Meta_linalg_ldl_solve_out_out(LD, pivots, B, hermitian, out); } at::Tensor & linalg_ldl_solve_outf(const at::Tensor & LD, const at::Tensor & pivots, const at::Tensor & B, bool hermitian, at::Tensor & out) { return wrapper_Meta_linalg_ldl_solve_out_out(LD, pivots, B, hermitian, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__linalg_slogdet_meta_functional final : public at::meta::structured__linalg_slogdet { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta__linalg_slogdet(const at::Tensor & A) { structured__linalg_slogdet_meta_functional op; op.meta(A); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2]), std::move(op.outputs_[3])); } struct structured__linalg_slogdet_meta_out final : public at::meta::structured__linalg_slogdet { structured__linalg_slogdet_meta_out(Tensor& out0, Tensor& out1, Tensor& out2, Tensor& out3) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2), std::ref(out3) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 4> outputs_; std::array<::std::optional, 4> proxy_outputs_; }; ::std::tuple wrapper_Meta__linalg_slogdet_out_sign(const at::Tensor & A, at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots) { structured__linalg_slogdet_meta_out op(sign, logabsdet, LU, pivots); op.meta(A); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); if (op.proxy_outputs_[3].has_value()) op.outputs_[3].get().copy_(*op.proxy_outputs_[3]); return std::forward_as_tuple(sign, logabsdet, LU, pivots); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_linalg_slogdet", TORCH_FN(wrapper_Meta__linalg_slogdet)); m.impl("_linalg_slogdet.sign", TORCH_FN(wrapper_Meta__linalg_slogdet_out_sign)); } } // anonymous namespace namespace meta { ::std::tuple _linalg_slogdet(const at::Tensor & A) { return wrapper_Meta__linalg_slogdet(A); } ::std::tuple _linalg_slogdet_out(at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots, const at::Tensor & A) { return wrapper_Meta__linalg_slogdet_out_sign(A, sign, logabsdet, LU, pivots); } ::std::tuple _linalg_slogdet_outf(const at::Tensor & A, at::Tensor & sign, at::Tensor & logabsdet, at::Tensor & LU, at::Tensor & pivots) { return wrapper_Meta__linalg_slogdet_out_sign(A, sign, logabsdet, LU, pivots); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__linalg_eigh_meta_functional final : public at::meta::structured__linalg_eigh { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta__linalg_eigh(const at::Tensor & A, c10::string_view UPLO, bool compute_v) { structured__linalg_eigh_meta_functional op; op.meta(A, UPLO, compute_v); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured__linalg_eigh_meta_out final : public at::meta::structured__linalg_eigh { structured__linalg_eigh_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta__linalg_eigh_out_eigenvalues(const at::Tensor & A, c10::string_view UPLO, bool compute_v, at::Tensor & eigenvalues, at::Tensor & eigenvectors) { structured__linalg_eigh_meta_out op(eigenvalues, eigenvectors); op.meta(A, UPLO, compute_v); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(eigenvalues, eigenvectors); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_linalg_eigh", TORCH_FN(wrapper_Meta__linalg_eigh)); m.impl("_linalg_eigh.eigenvalues", TORCH_FN(wrapper_Meta__linalg_eigh_out_eigenvalues)); } } // anonymous namespace namespace meta { ::std::tuple _linalg_eigh(const at::Tensor & A, c10::string_view UPLO, bool compute_v) { return wrapper_Meta__linalg_eigh(A, UPLO, compute_v); } ::std::tuple _linalg_eigh_out(at::Tensor & eigenvalues, at::Tensor & eigenvectors, const at::Tensor & A, c10::string_view UPLO, bool compute_v) { return wrapper_Meta__linalg_eigh_out_eigenvalues(A, UPLO, compute_v, eigenvalues, eigenvectors); } ::std::tuple _linalg_eigh_outf(const at::Tensor & A, c10::string_view UPLO, bool compute_v, at::Tensor & eigenvalues, at::Tensor & eigenvectors) { return wrapper_Meta__linalg_eigh_out_eigenvalues(A, UPLO, compute_v, eigenvalues, eigenvectors); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_inv_ex_meta_functional final : public at::meta::structured_linalg_inv_ex { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_inv_ex(const at::Tensor & A, bool check_errors) { structured_linalg_inv_ex_meta_functional op; op.meta(A, check_errors); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_linalg_inv_ex_meta_out final : public at::meta::structured_linalg_inv_ex { structured_linalg_inv_ex_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_inv_ex_out_inverse(const at::Tensor & A, bool check_errors, at::Tensor & inverse, at::Tensor & info) { structured_linalg_inv_ex_meta_out op(inverse, info); op.meta(A, check_errors); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(inverse, info); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_inv_ex", TORCH_FN(wrapper_Meta_linalg_inv_ex)); m.impl("linalg_inv_ex.inverse", TORCH_FN(wrapper_Meta_linalg_inv_ex_out_inverse)); } } // anonymous namespace namespace meta { ::std::tuple linalg_inv_ex(const at::Tensor & A, bool check_errors) { return wrapper_Meta_linalg_inv_ex(A, check_errors); } ::std::tuple linalg_inv_ex_out(at::Tensor & inverse, at::Tensor & info, const at::Tensor & A, bool check_errors) { return wrapper_Meta_linalg_inv_ex_out_inverse(A, check_errors, inverse, info); } ::std::tuple linalg_inv_ex_outf(const at::Tensor & A, bool check_errors, at::Tensor & inverse, at::Tensor & info) { return wrapper_Meta_linalg_inv_ex_out_inverse(A, check_errors, inverse, info); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_vector_norm_meta_functional final : public at::meta::structured_linalg_vector_norm { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_linalg_vector_norm(const at::Tensor & self, const at::Scalar & ord, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { structured_linalg_vector_norm_meta_functional op; op.meta(self, ord, dim, keepdim, dtype); return std::move(op.outputs_[0]); } struct structured_linalg_vector_norm_meta_out final : public at::meta::structured_linalg_vector_norm { structured_linalg_vector_norm_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_linalg_vector_norm_out_out(const at::Tensor & self, const at::Scalar & ord, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { structured_linalg_vector_norm_meta_out op(out); op.meta(self, ord, dim, keepdim, dtype); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_vector_norm", TORCH_FN(wrapper_Meta_linalg_vector_norm)); m.impl("linalg_vector_norm.out", TORCH_FN(wrapper_Meta_linalg_vector_norm_out_out)); } } // anonymous namespace namespace meta { at::Tensor linalg_vector_norm(const at::Tensor & self, const at::Scalar & ord, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_linalg_vector_norm(self, ord, dim, keepdim, dtype); } at::Tensor & linalg_vector_norm_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & ord, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype) { return wrapper_Meta_linalg_vector_norm_out_out(self, ord, dim, keepdim, dtype, out); } at::Tensor & linalg_vector_norm_outf(const at::Tensor & self, const at::Scalar & ord, at::OptionalIntArrayRef dim, bool keepdim, ::std::optional dtype, at::Tensor & out) { return wrapper_Meta_linalg_vector_norm_out_out(self, ord, dim, keepdim, dtype, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__linalg_svd_meta_functional final : public at::meta::structured__linalg_svd { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta__linalg_svd(const at::Tensor & A, bool full_matrices, bool compute_uv, ::std::optional driver) { structured__linalg_svd_meta_functional op; op.meta(A, full_matrices, compute_uv, driver); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2])); } struct structured__linalg_svd_meta_out final : public at::meta::structured__linalg_svd { structured__linalg_svd_meta_out(Tensor& out0, Tensor& out1, Tensor& out2) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 3> outputs_; std::array<::std::optional, 3> proxy_outputs_; }; ::std::tuple wrapper_Meta__linalg_svd_out_U(const at::Tensor & A, bool full_matrices, bool compute_uv, ::std::optional driver, at::Tensor & U, at::Tensor & S, at::Tensor & Vh) { structured__linalg_svd_meta_out op(U, S, Vh); op.meta(A, full_matrices, compute_uv, driver); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); return std::forward_as_tuple(U, S, Vh); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_linalg_svd", TORCH_FN(wrapper_Meta__linalg_svd)); m.impl("_linalg_svd.U", TORCH_FN(wrapper_Meta__linalg_svd_out_U)); } } // anonymous namespace namespace meta { ::std::tuple _linalg_svd(const at::Tensor & A, bool full_matrices, bool compute_uv, ::std::optional driver) { return wrapper_Meta__linalg_svd(A, full_matrices, compute_uv, driver); } ::std::tuple _linalg_svd_out(at::Tensor & U, at::Tensor & S, at::Tensor & Vh, const at::Tensor & A, bool full_matrices, bool compute_uv, ::std::optional driver) { return wrapper_Meta__linalg_svd_out_U(A, full_matrices, compute_uv, driver, U, S, Vh); } ::std::tuple _linalg_svd_outf(const at::Tensor & A, bool full_matrices, bool compute_uv, ::std::optional driver, at::Tensor & U, at::Tensor & S, at::Tensor & Vh) { return wrapper_Meta__linalg_svd_out_U(A, full_matrices, compute_uv, driver, U, S, Vh); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured__linalg_solve_ex_meta_functional final : public at::meta::structured__linalg_solve_ex { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta__linalg_solve_ex(const at::Tensor & A, const at::Tensor & B, bool left, bool check_errors) { structured__linalg_solve_ex_meta_functional op; op.meta(A, B, left, check_errors); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1]), std::move(op.outputs_[2]), std::move(op.outputs_[3])); } struct structured__linalg_solve_ex_meta_out final : public at::meta::structured__linalg_solve_ex { structured__linalg_solve_ex_meta_out(Tensor& out0, Tensor& out1, Tensor& out2, Tensor& out3) : outputs_{ std::ref(out0), std::ref(out1), std::ref(out2), std::ref(out3) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 4> outputs_; std::array<::std::optional, 4> proxy_outputs_; }; ::std::tuple wrapper_Meta__linalg_solve_ex_out_result(const at::Tensor & A, const at::Tensor & B, bool left, bool check_errors, at::Tensor & result, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info) { structured__linalg_solve_ex_meta_out op(result, LU, pivots, info); op.meta(A, B, left, check_errors); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); if (op.proxy_outputs_[2].has_value()) op.outputs_[2].get().copy_(*op.proxy_outputs_[2]); if (op.proxy_outputs_[3].has_value()) op.outputs_[3].get().copy_(*op.proxy_outputs_[3]); return std::forward_as_tuple(result, LU, pivots, info); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_linalg_solve_ex", TORCH_FN(wrapper_Meta__linalg_solve_ex)); m.impl("_linalg_solve_ex.result", TORCH_FN(wrapper_Meta__linalg_solve_ex_out_result)); } } // anonymous namespace namespace meta { ::std::tuple _linalg_solve_ex(const at::Tensor & A, const at::Tensor & B, bool left, bool check_errors) { return wrapper_Meta__linalg_solve_ex(A, B, left, check_errors); } ::std::tuple _linalg_solve_ex_out(at::Tensor & result, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info, const at::Tensor & A, const at::Tensor & B, bool left, bool check_errors) { return wrapper_Meta__linalg_solve_ex_out_result(A, B, left, check_errors, result, LU, pivots, info); } ::std::tuple _linalg_solve_ex_outf(const at::Tensor & A, const at::Tensor & B, bool left, bool check_errors, at::Tensor & result, at::Tensor & LU, at::Tensor & pivots, at::Tensor & info) { return wrapper_Meta__linalg_solve_ex_out_result(A, B, left, check_errors, result, LU, pivots, info); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_linalg_qr_meta_functional final : public at::meta::structured_linalg_qr { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; ::std::tuple wrapper_Meta_linalg_qr(const at::Tensor & A, c10::string_view mode) { structured_linalg_qr_meta_functional op; op.meta(A, mode); return std::make_tuple(std::move(op.outputs_[0]), std::move(op.outputs_[1])); } struct structured_linalg_qr_meta_out final : public at::meta::structured_linalg_qr { structured_linalg_qr_meta_out(Tensor& out0, Tensor& out1) : outputs_{ std::ref(out0), std::ref(out1) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 2> outputs_; std::array<::std::optional, 2> proxy_outputs_; }; ::std::tuple wrapper_Meta_linalg_qr_out_out(const at::Tensor & A, c10::string_view mode, at::Tensor & Q, at::Tensor & R) { structured_linalg_qr_meta_out op(Q, R); op.meta(A, mode); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); if (op.proxy_outputs_[1].has_value()) op.outputs_[1].get().copy_(*op.proxy_outputs_[1]); return std::forward_as_tuple(Q, R); } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("linalg_qr", TORCH_FN(wrapper_Meta_linalg_qr)); m.impl("linalg_qr.out", TORCH_FN(wrapper_Meta_linalg_qr_out_out)); } } // anonymous namespace namespace meta { ::std::tuple linalg_qr(const at::Tensor & A, c10::string_view mode) { return wrapper_Meta_linalg_qr(A, mode); } ::std::tuple linalg_qr_out(at::Tensor & Q, at::Tensor & R, const at::Tensor & A, c10::string_view mode) { return wrapper_Meta_linalg_qr_out_out(A, mode, Q, R); } ::std::tuple linalg_qr_outf(const at::Tensor & A, c10::string_view mode, at::Tensor & Q, at::Tensor & R) { return wrapper_Meta_linalg_qr_out_out(A, mode, Q, R); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { namespace { int64_t wrapper_Meta___fused_sdp_choice(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional & attn_mask, double dropout_p, bool is_causal, ::std::optional scale, bool enable_gqa) { // No device check // DeviceGuard omitted return at::native::_fused_sdp_choice_meta(query, key, value, attn_mask, dropout_p, is_causal, scale, enable_gqa); } } // anonymous namespace TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_fused_sdp_choice", TORCH_FN(wrapper_Meta___fused_sdp_choice)); } } // anonymous namespace namespace meta { int64_t _fused_sdp_choice(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional & attn_mask, double dropout_p, bool is_causal, ::std::optional scale, bool enable_gqa) { return wrapper_Meta___fused_sdp_choice(query, key, value, attn_mask, dropout_p, is_causal, scale, enable_gqa); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { at::Tensor & wrapper_Meta___fill_mem_eff_dropout_mask_(at::Tensor & self, double dropout_p, int64_t seed, int64_t offset) { TORCH_CHECK_NOT_IMPLEMENTED(self.is_meta(), "Cannot inplace into non-meta tensor with meta tensor argument"); return self; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("_fill_mem_eff_dropout_mask_", TORCH_FN(wrapper_Meta___fill_mem_eff_dropout_mask_)); } } // anonymous namespace namespace meta { at::Tensor & _fill_mem_eff_dropout_mask_(at::Tensor & self, double dropout_p, int64_t seed, int64_t offset) { return wrapper_Meta___fill_mem_eff_dropout_mask_(self, dropout_p, seed, offset); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_airy_ai_meta_functional final : public at::meta::structured_special_airy_ai { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_airy_ai::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_airy_ai::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_airy_ai(const at::Tensor & x) { structured_special_airy_ai_meta_functional op; op.meta(x); return std::move(op.outputs_[0]); } struct structured_special_airy_ai_meta_out final : public at::meta::structured_special_airy_ai { structured_special_airy_ai_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_airy_ai::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_airy_ai::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_airy_ai_out_out(const at::Tensor & x, at::Tensor & out) { structured_special_airy_ai_meta_out op(out); op.meta(x); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_airy_ai", TORCH_FN(wrapper_Meta_special_airy_ai)); m.impl("special_airy_ai.out", TORCH_FN(wrapper_Meta_special_airy_ai_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_airy_ai(const at::Tensor & x) { return wrapper_Meta_special_airy_ai(x); } at::Tensor & special_airy_ai_out(at::Tensor & out, const at::Tensor & x) { return wrapper_Meta_special_airy_ai_out_out(x, out); } at::Tensor & special_airy_ai_outf(const at::Tensor & x, at::Tensor & out) { return wrapper_Meta_special_airy_ai_out_out(x, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_bessel_j0_meta_functional final : public at::meta::structured_special_bessel_j0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_bessel_j0(const at::Tensor & self) { structured_special_bessel_j0_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_bessel_j0_meta_out final : public at::meta::structured_special_bessel_j0 { structured_special_bessel_j0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_bessel_j0_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_bessel_j0_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_bessel_j0", TORCH_FN(wrapper_Meta_special_bessel_j0)); m.impl("special_bessel_j0.out", TORCH_FN(wrapper_Meta_special_bessel_j0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_bessel_j0(const at::Tensor & self) { return wrapper_Meta_special_bessel_j0(self); } at::Tensor & special_bessel_j0_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_bessel_j0_out_out(self, out); } at::Tensor & special_bessel_j0_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_bessel_j0_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_bessel_j1_meta_functional final : public at::meta::structured_special_bessel_j1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_bessel_j1(const at::Tensor & self) { structured_special_bessel_j1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_bessel_j1_meta_out final : public at::meta::structured_special_bessel_j1 { structured_special_bessel_j1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_j1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_bessel_j1_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_bessel_j1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_bessel_j1", TORCH_FN(wrapper_Meta_special_bessel_j1)); m.impl("special_bessel_j1.out", TORCH_FN(wrapper_Meta_special_bessel_j1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_bessel_j1(const at::Tensor & self) { return wrapper_Meta_special_bessel_j1(self); } at::Tensor & special_bessel_j1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_bessel_j1_out_out(self, out); } at::Tensor & special_bessel_j1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_bessel_j1_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_bessel_y0_meta_functional final : public at::meta::structured_special_bessel_y0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_bessel_y0(const at::Tensor & self) { structured_special_bessel_y0_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_bessel_y0_meta_out final : public at::meta::structured_special_bessel_y0 { structured_special_bessel_y0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_bessel_y0_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_bessel_y0_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_bessel_y0", TORCH_FN(wrapper_Meta_special_bessel_y0)); m.impl("special_bessel_y0.out", TORCH_FN(wrapper_Meta_special_bessel_y0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_bessel_y0(const at::Tensor & self) { return wrapper_Meta_special_bessel_y0(self); } at::Tensor & special_bessel_y0_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_bessel_y0_out_out(self, out); } at::Tensor & special_bessel_y0_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_bessel_y0_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_bessel_y1_meta_functional final : public at::meta::structured_special_bessel_y1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_bessel_y1(const at::Tensor & self) { structured_special_bessel_y1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_bessel_y1_meta_out final : public at::meta::structured_special_bessel_y1 { structured_special_bessel_y1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_bessel_y1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_bessel_y1_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_bessel_y1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_bessel_y1", TORCH_FN(wrapper_Meta_special_bessel_y1)); m.impl("special_bessel_y1.out", TORCH_FN(wrapper_Meta_special_bessel_y1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_bessel_y1(const at::Tensor & self) { return wrapper_Meta_special_bessel_y1(self); } at::Tensor & special_bessel_y1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_bessel_y1_out_out(self, out); } at::Tensor & special_bessel_y1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_bessel_y1_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_chebyshev_polynomial_t_meta_functional final : public at::meta::structured_special_chebyshev_polynomial_t { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_chebyshev_polynomial_t(const at::Tensor & x, const at::Tensor & n) { structured_special_chebyshev_polynomial_t_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_chebyshev_polynomial_t_meta_out final : public at::meta::structured_special_chebyshev_polynomial_t { structured_special_chebyshev_polynomial_t_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_chebyshev_polynomial_t_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_chebyshev_polynomial_t_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_chebyshev_polynomial_t", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_t)); m.impl("special_chebyshev_polynomial_t.out", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_t_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_chebyshev_polynomial_t(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_t(x, n); } at::Tensor & special_chebyshev_polynomial_t_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_t_out_out(x, n, out); } at::Tensor & special_chebyshev_polynomial_t_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_chebyshev_polynomial_t_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_chebyshev_polynomial_u_meta_functional final : public at::meta::structured_special_chebyshev_polynomial_u { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n) { structured_special_chebyshev_polynomial_u_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_chebyshev_polynomial_u_meta_out final : public at::meta::structured_special_chebyshev_polynomial_u { structured_special_chebyshev_polynomial_u_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_chebyshev_polynomial_u_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_chebyshev_polynomial_u_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_chebyshev_polynomial_u", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_u)); m.impl("special_chebyshev_polynomial_u.out", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_u_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_u(x, n); } at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_u_out_out(x, n, out); } at::Tensor & special_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_chebyshev_polynomial_u_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_chebyshev_polynomial_v_meta_functional final : public at::meta::structured_special_chebyshev_polynomial_v { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_chebyshev_polynomial_v(const at::Tensor & x, const at::Tensor & n) { structured_special_chebyshev_polynomial_v_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_chebyshev_polynomial_v_meta_out final : public at::meta::structured_special_chebyshev_polynomial_v { structured_special_chebyshev_polynomial_v_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_chebyshev_polynomial_v_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_chebyshev_polynomial_v_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_chebyshev_polynomial_v", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_v)); m.impl("special_chebyshev_polynomial_v.out", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_v_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_chebyshev_polynomial_v(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_v(x, n); } at::Tensor & special_chebyshev_polynomial_v_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_v_out_out(x, n, out); } at::Tensor & special_chebyshev_polynomial_v_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_chebyshev_polynomial_v_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_chebyshev_polynomial_w_meta_functional final : public at::meta::structured_special_chebyshev_polynomial_w { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_chebyshev_polynomial_w(const at::Tensor & x, const at::Tensor & n) { structured_special_chebyshev_polynomial_w_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_chebyshev_polynomial_w_meta_out final : public at::meta::structured_special_chebyshev_polynomial_w { structured_special_chebyshev_polynomial_w_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_chebyshev_polynomial_w_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_chebyshev_polynomial_w_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_chebyshev_polynomial_w", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_w)); m.impl("special_chebyshev_polynomial_w.out", TORCH_FN(wrapper_Meta_special_chebyshev_polynomial_w_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_chebyshev_polynomial_w(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_w(x, n); } at::Tensor & special_chebyshev_polynomial_w_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_chebyshev_polynomial_w_out_out(x, n, out); } at::Tensor & special_chebyshev_polynomial_w_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_chebyshev_polynomial_w_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_hermite_polynomial_h_meta_functional final : public at::meta::structured_special_hermite_polynomial_h { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_h::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_h::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_hermite_polynomial_h(const at::Tensor & x, const at::Tensor & n) { structured_special_hermite_polynomial_h_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_hermite_polynomial_h_meta_out final : public at::meta::structured_special_hermite_polynomial_h { structured_special_hermite_polynomial_h_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_h::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_h::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_hermite_polynomial_h_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_hermite_polynomial_h_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_hermite_polynomial_h", TORCH_FN(wrapper_Meta_special_hermite_polynomial_h)); m.impl("special_hermite_polynomial_h.out", TORCH_FN(wrapper_Meta_special_hermite_polynomial_h_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_hermite_polynomial_h(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_hermite_polynomial_h(x, n); } at::Tensor & special_hermite_polynomial_h_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_hermite_polynomial_h_out_out(x, n, out); } at::Tensor & special_hermite_polynomial_h_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_hermite_polynomial_h_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_hermite_polynomial_he_meta_functional final : public at::meta::structured_special_hermite_polynomial_he { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_he::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_he::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_hermite_polynomial_he(const at::Tensor & x, const at::Tensor & n) { structured_special_hermite_polynomial_he_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_hermite_polynomial_he_meta_out final : public at::meta::structured_special_hermite_polynomial_he { structured_special_hermite_polynomial_he_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_he::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_hermite_polynomial_he::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_hermite_polynomial_he_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_hermite_polynomial_he_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_hermite_polynomial_he", TORCH_FN(wrapper_Meta_special_hermite_polynomial_he)); m.impl("special_hermite_polynomial_he.out", TORCH_FN(wrapper_Meta_special_hermite_polynomial_he_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_hermite_polynomial_he(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_hermite_polynomial_he(x, n); } at::Tensor & special_hermite_polynomial_he_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_hermite_polynomial_he_out_out(x, n, out); } at::Tensor & special_hermite_polynomial_he_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_hermite_polynomial_he_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_laguerre_polynomial_l_meta_functional final : public at::meta::structured_special_laguerre_polynomial_l { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_laguerre_polynomial_l::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_laguerre_polynomial_l::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_laguerre_polynomial_l(const at::Tensor & x, const at::Tensor & n) { structured_special_laguerre_polynomial_l_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_laguerre_polynomial_l_meta_out final : public at::meta::structured_special_laguerre_polynomial_l { structured_special_laguerre_polynomial_l_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_laguerre_polynomial_l::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_laguerre_polynomial_l::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_laguerre_polynomial_l_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_laguerre_polynomial_l_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_laguerre_polynomial_l", TORCH_FN(wrapper_Meta_special_laguerre_polynomial_l)); m.impl("special_laguerre_polynomial_l.out", TORCH_FN(wrapper_Meta_special_laguerre_polynomial_l_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_laguerre_polynomial_l(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_laguerre_polynomial_l(x, n); } at::Tensor & special_laguerre_polynomial_l_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_laguerre_polynomial_l_out_out(x, n, out); } at::Tensor & special_laguerre_polynomial_l_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_laguerre_polynomial_l_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_legendre_polynomial_p_meta_functional final : public at::meta::structured_special_legendre_polynomial_p { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_legendre_polynomial_p::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_legendre_polynomial_p::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_legendre_polynomial_p(const at::Tensor & x, const at::Tensor & n) { structured_special_legendre_polynomial_p_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_legendre_polynomial_p_meta_out final : public at::meta::structured_special_legendre_polynomial_p { structured_special_legendre_polynomial_p_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_legendre_polynomial_p::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_legendre_polynomial_p::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_legendre_polynomial_p_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_legendre_polynomial_p_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_legendre_polynomial_p", TORCH_FN(wrapper_Meta_special_legendre_polynomial_p)); m.impl("special_legendre_polynomial_p.out", TORCH_FN(wrapper_Meta_special_legendre_polynomial_p_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_legendre_polynomial_p(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_legendre_polynomial_p(x, n); } at::Tensor & special_legendre_polynomial_p_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_legendre_polynomial_p_out_out(x, n, out); } at::Tensor & special_legendre_polynomial_p_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_legendre_polynomial_p_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_modified_bessel_i0_meta_functional final : public at::meta::structured_special_modified_bessel_i0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_modified_bessel_i0(const at::Tensor & self) { structured_special_modified_bessel_i0_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_modified_bessel_i0_meta_out final : public at::meta::structured_special_modified_bessel_i0 { structured_special_modified_bessel_i0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_modified_bessel_i0_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_modified_bessel_i0_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_modified_bessel_i0", TORCH_FN(wrapper_Meta_special_modified_bessel_i0)); m.impl("special_modified_bessel_i0.out", TORCH_FN(wrapper_Meta_special_modified_bessel_i0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_modified_bessel_i0(const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_i0(self); } at::Tensor & special_modified_bessel_i0_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_i0_out_out(self, out); } at::Tensor & special_modified_bessel_i0_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_modified_bessel_i0_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_modified_bessel_i1_meta_functional final : public at::meta::structured_special_modified_bessel_i1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_modified_bessel_i1(const at::Tensor & self) { structured_special_modified_bessel_i1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_modified_bessel_i1_meta_out final : public at::meta::structured_special_modified_bessel_i1 { structured_special_modified_bessel_i1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_i1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_modified_bessel_i1_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_modified_bessel_i1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_modified_bessel_i1", TORCH_FN(wrapper_Meta_special_modified_bessel_i1)); m.impl("special_modified_bessel_i1.out", TORCH_FN(wrapper_Meta_special_modified_bessel_i1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_modified_bessel_i1(const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_i1(self); } at::Tensor & special_modified_bessel_i1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_i1_out_out(self, out); } at::Tensor & special_modified_bessel_i1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_modified_bessel_i1_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_modified_bessel_k0_meta_functional final : public at::meta::structured_special_modified_bessel_k0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_modified_bessel_k0(const at::Tensor & self) { structured_special_modified_bessel_k0_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_modified_bessel_k0_meta_out final : public at::meta::structured_special_modified_bessel_k0 { structured_special_modified_bessel_k0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_modified_bessel_k0_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_modified_bessel_k0_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_modified_bessel_k0", TORCH_FN(wrapper_Meta_special_modified_bessel_k0)); m.impl("special_modified_bessel_k0.out", TORCH_FN(wrapper_Meta_special_modified_bessel_k0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_modified_bessel_k0(const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_k0(self); } at::Tensor & special_modified_bessel_k0_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_k0_out_out(self, out); } at::Tensor & special_modified_bessel_k0_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_modified_bessel_k0_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_modified_bessel_k1_meta_functional final : public at::meta::structured_special_modified_bessel_k1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_modified_bessel_k1(const at::Tensor & self) { structured_special_modified_bessel_k1_meta_functional op; op.meta(self); return std::move(op.outputs_[0]); } struct structured_special_modified_bessel_k1_meta_out final : public at::meta::structured_special_modified_bessel_k1 { structured_special_modified_bessel_k1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_modified_bessel_k1_out_out(const at::Tensor & self, at::Tensor & out) { structured_special_modified_bessel_k1_meta_out op(out); op.meta(self); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_modified_bessel_k1", TORCH_FN(wrapper_Meta_special_modified_bessel_k1)); m.impl("special_modified_bessel_k1.out", TORCH_FN(wrapper_Meta_special_modified_bessel_k1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_modified_bessel_k1(const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_k1(self); } at::Tensor & special_modified_bessel_k1_out(at::Tensor & out, const at::Tensor & self) { return wrapper_Meta_special_modified_bessel_k1_out_out(self, out); } at::Tensor & special_modified_bessel_k1_outf(const at::Tensor & self, at::Tensor & out) { return wrapper_Meta_special_modified_bessel_k1_out_out(self, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_scaled_modified_bessel_k0_meta_functional final : public at::meta::structured_special_scaled_modified_bessel_k0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_scaled_modified_bessel_k0(const at::Tensor & x) { structured_special_scaled_modified_bessel_k0_meta_functional op; op.meta(x); return std::move(op.outputs_[0]); } struct structured_special_scaled_modified_bessel_k0_meta_out final : public at::meta::structured_special_scaled_modified_bessel_k0 { structured_special_scaled_modified_bessel_k0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_scaled_modified_bessel_k0_out_out(const at::Tensor & x, at::Tensor & out) { structured_special_scaled_modified_bessel_k0_meta_out op(out); op.meta(x); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_scaled_modified_bessel_k0", TORCH_FN(wrapper_Meta_special_scaled_modified_bessel_k0)); m.impl("special_scaled_modified_bessel_k0.out", TORCH_FN(wrapper_Meta_special_scaled_modified_bessel_k0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_scaled_modified_bessel_k0(const at::Tensor & x) { return wrapper_Meta_special_scaled_modified_bessel_k0(x); } at::Tensor & special_scaled_modified_bessel_k0_out(at::Tensor & out, const at::Tensor & x) { return wrapper_Meta_special_scaled_modified_bessel_k0_out_out(x, out); } at::Tensor & special_scaled_modified_bessel_k0_outf(const at::Tensor & x, at::Tensor & out) { return wrapper_Meta_special_scaled_modified_bessel_k0_out_out(x, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_scaled_modified_bessel_k1_meta_functional final : public at::meta::structured_special_scaled_modified_bessel_k1 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_scaled_modified_bessel_k1(const at::Tensor & x) { structured_special_scaled_modified_bessel_k1_meta_functional op; op.meta(x); return std::move(op.outputs_[0]); } struct structured_special_scaled_modified_bessel_k1_meta_out final : public at::meta::structured_special_scaled_modified_bessel_k1 { structured_special_scaled_modified_bessel_k1_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_scaled_modified_bessel_k1::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_scaled_modified_bessel_k1_out_out(const at::Tensor & x, at::Tensor & out) { structured_special_scaled_modified_bessel_k1_meta_out op(out); op.meta(x); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_scaled_modified_bessel_k1", TORCH_FN(wrapper_Meta_special_scaled_modified_bessel_k1)); m.impl("special_scaled_modified_bessel_k1.out", TORCH_FN(wrapper_Meta_special_scaled_modified_bessel_k1_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_scaled_modified_bessel_k1(const at::Tensor & x) { return wrapper_Meta_special_scaled_modified_bessel_k1(x); } at::Tensor & special_scaled_modified_bessel_k1_out(at::Tensor & out, const at::Tensor & x) { return wrapper_Meta_special_scaled_modified_bessel_k1_out_out(x, out); } at::Tensor & special_scaled_modified_bessel_k1_outf(const at::Tensor & x, at::Tensor & out) { return wrapper_Meta_special_scaled_modified_bessel_k1_out_out(x, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_shifted_chebyshev_polynomial_t_meta_functional final : public at::meta::structured_special_shifted_chebyshev_polynomial_t { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_shifted_chebyshev_polynomial_t(const at::Tensor & x, const at::Tensor & n) { structured_special_shifted_chebyshev_polynomial_t_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_shifted_chebyshev_polynomial_t_meta_out final : public at::meta::structured_special_shifted_chebyshev_polynomial_t { structured_special_shifted_chebyshev_polynomial_t_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_t::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_shifted_chebyshev_polynomial_t_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_shifted_chebyshev_polynomial_t_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_shifted_chebyshev_polynomial_t", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_t)); m.impl("special_shifted_chebyshev_polynomial_t.out", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_t_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_shifted_chebyshev_polynomial_t(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_t(x, n); } at::Tensor & special_shifted_chebyshev_polynomial_t_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_t_out_out(x, n, out); } at::Tensor & special_shifted_chebyshev_polynomial_t_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_shifted_chebyshev_polynomial_t_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_shifted_chebyshev_polynomial_u_meta_functional final : public at::meta::structured_special_shifted_chebyshev_polynomial_u { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_shifted_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n) { structured_special_shifted_chebyshev_polynomial_u_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_shifted_chebyshev_polynomial_u_meta_out final : public at::meta::structured_special_shifted_chebyshev_polynomial_u { structured_special_shifted_chebyshev_polynomial_u_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_u::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_shifted_chebyshev_polynomial_u_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_shifted_chebyshev_polynomial_u_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_shifted_chebyshev_polynomial_u", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_u)); m.impl("special_shifted_chebyshev_polynomial_u.out", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_u_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_shifted_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_u(x, n); } at::Tensor & special_shifted_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_u_out_out(x, n, out); } at::Tensor & special_shifted_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_shifted_chebyshev_polynomial_u_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_shifted_chebyshev_polynomial_v_meta_functional final : public at::meta::structured_special_shifted_chebyshev_polynomial_v { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_shifted_chebyshev_polynomial_v(const at::Tensor & x, const at::Tensor & n) { structured_special_shifted_chebyshev_polynomial_v_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_shifted_chebyshev_polynomial_v_meta_out final : public at::meta::structured_special_shifted_chebyshev_polynomial_v { structured_special_shifted_chebyshev_polynomial_v_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_v::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_shifted_chebyshev_polynomial_v_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_shifted_chebyshev_polynomial_v_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_shifted_chebyshev_polynomial_v", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_v)); m.impl("special_shifted_chebyshev_polynomial_v.out", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_v_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_shifted_chebyshev_polynomial_v(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_v(x, n); } at::Tensor & special_shifted_chebyshev_polynomial_v_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_v_out_out(x, n, out); } at::Tensor & special_shifted_chebyshev_polynomial_v_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_shifted_chebyshev_polynomial_v_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_shifted_chebyshev_polynomial_w_meta_functional final : public at::meta::structured_special_shifted_chebyshev_polynomial_w { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_shifted_chebyshev_polynomial_w(const at::Tensor & x, const at::Tensor & n) { structured_special_shifted_chebyshev_polynomial_w_meta_functional op; op.meta(x, n); return std::move(op.outputs_[0]); } struct structured_special_shifted_chebyshev_polynomial_w_meta_out final : public at::meta::structured_special_shifted_chebyshev_polynomial_w { structured_special_shifted_chebyshev_polynomial_w_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_shifted_chebyshev_polynomial_w::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_shifted_chebyshev_polynomial_w_out_out(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { structured_special_shifted_chebyshev_polynomial_w_meta_out op(out); op.meta(x, n); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_shifted_chebyshev_polynomial_w", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_w)); m.impl("special_shifted_chebyshev_polynomial_w.out", TORCH_FN(wrapper_Meta_special_shifted_chebyshev_polynomial_w_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_shifted_chebyshev_polynomial_w(const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_w(x, n); } at::Tensor & special_shifted_chebyshev_polynomial_w_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & n) { return wrapper_Meta_special_shifted_chebyshev_polynomial_w_out_out(x, n, out); } at::Tensor & special_shifted_chebyshev_polynomial_w_outf(const at::Tensor & x, const at::Tensor & n, at::Tensor & out) { return wrapper_Meta_special_shifted_chebyshev_polynomial_w_out_out(x, n, out); } } // namespace meta } // namespace at namespace at { // NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid // ambiguity with conflicting identifiers that may have been defined in // at namespace already. namespace { struct structured_special_spherical_bessel_j0_meta_functional final : public at::meta::structured_special_spherical_bessel_j0 { void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_spherical_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { outputs_[output_idx] = create_out(sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_spherical_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return outputs_[output_idx]; } std::array outputs_; }; at::Tensor wrapper_Meta_special_spherical_bessel_j0(const at::Tensor & x) { structured_special_spherical_bessel_j0_meta_functional op; op.meta(x); return std::move(op.outputs_[0]); } struct structured_special_spherical_bessel_j0_meta_out final : public at::meta::structured_special_spherical_bessel_j0 { structured_special_spherical_bessel_j0_meta_out(Tensor& out0) : outputs_{ std::ref(out0) } {} void set_output_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options); if (C10_UNLIKELY(maybe_proxy.has_value())) { proxy_outputs_[output_idx] = std::move(maybe_proxy).value(); } if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_spherical_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } void set_output_raw_strided( int64_t output_idx, IntArrayRef sizes, IntArrayRef strides, TensorOptions options, DimnameList names ) override { const auto& out = outputs_[output_idx].get(); resize_out(out, sizes, strides, options); if (!names.empty()) { namedinference::propagate_names(outputs_[output_idx], names); } // super must happen after, so that downstream can use maybe_get_output // to retrieve the output at::meta::structured_special_spherical_bessel_j0::set_output_raw_strided(output_idx, sizes, strides, options, names); } const Tensor& maybe_get_output(int64_t output_idx) override { return proxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get(); } std::array, 1> outputs_; std::array<::std::optional, 1> proxy_outputs_; }; at::Tensor & wrapper_Meta_special_spherical_bessel_j0_out_out(const at::Tensor & x, at::Tensor & out) { structured_special_spherical_bessel_j0_meta_out op(out); op.meta(x); if (op.proxy_outputs_[0].has_value()) op.outputs_[0].get().copy_(*op.proxy_outputs_[0]); return out; } TORCH_LIBRARY_IMPL(aten, Meta, m) { m.impl("special_spherical_bessel_j0", TORCH_FN(wrapper_Meta_special_spherical_bessel_j0)); m.impl("special_spherical_bessel_j0.out", TORCH_FN(wrapper_Meta_special_spherical_bessel_j0_out_out)); } } // anonymous namespace namespace meta { at::Tensor special_spherical_bessel_j0(const at::Tensor & x) { return wrapper_Meta_special_spherical_bessel_j0(x); } at::Tensor & special_spherical_bessel_j0_out(at::Tensor & out, const at::Tensor & x) { return wrapper_Meta_special_spherical_bessel_j0_out_out(x, out); } at::Tensor & special_spherical_bessel_j0_outf(const at::Tensor & x, at::Tensor & out) { return wrapper_Meta_special_spherical_bessel_j0_out_out(x, out); } } // namespace meta } // namespace at