frozenleaves/pytorch
1
0
Fork 0
mirror of https://github.com/pytorch/pytorch.git synced 2025-10-22 06:11:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Check function declarations of Vulkan code (#134550)

Browse Source 
Fixes #ISSUE_NUMBER

Pull Request resolved: https://github.com/pytorch/pytorch/pull/134550
Approved by: https://github.com/ezyang
This commit is contained in:
cyy
2024-09-01 09:38:35 +00:00
committed by PyTorch MergeBot
parent c25b64a057
commit d03f767cae
19 changed files with 76 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
aten/src/ATen/native/vulkan/api/Pipeline.cpp
View File

@ -230,7 +230,7 @@ void swap(ComputePipeline& lhs, ComputePipeline& rhs) noexcept {
rhs.handle_ = tmp_handle; rhs.handle_ = tmp_handle;
} }
bool operator==( static bool operator==(
const ComputePipeline::Descriptor& _1, const ComputePipeline::Descriptor& _1,
const ComputePipeline::Descriptor& _2) { const ComputePipeline::Descriptor& _2) {
return ( return (

8
aten/src/ATen/native/vulkan/api/QueryPool.cpp
View File

@ -170,13 +170,7 @@ void QueryPool::extract_results() {
results_pending_ = false; results_pending_ = false;
} }
std::ostream& operator<<(std::ostream& os, const VkExtent3D& extents) { static std::string stringize(const VkExtent3D& extents) {
os << "{" << extents.width << ", " << extents.height << ", " << extents.depth
<< "}";
return os;
}
std::string stringize(const VkExtent3D& extents) {
std::stringstream ss; std::stringstream ss;
ss << "{" << extents.width << ", " << extents.height << ", " << extents.depth ss << "{" << extents.width << ", " << extents.height << ", " << extents.depth
<< "}"; << "}";

2
aten/src/ATen/native/vulkan/api/Resource.cpp
View File

@ -253,7 +253,7 @@ BufferMemoryBarrier::BufferMemoryBarrier(
// ImageSampler // ImageSampler
// //
bool operator==( static bool operator==(
const ImageSampler::Properties& _1, const ImageSampler::Properties& _1,
const ImageSampler::Properties& _2) { const ImageSampler::Properties& _2) {
return ( return (

4
aten/src/ATen/native/vulkan/api/Tensor.cpp
View File

@ -460,7 +460,7 @@ void vTensor::virtual_resize(const std::vector<int64_t>& new_sizes) {
// vTensorStorage // vTensorStorage
// //
api::VulkanImage allocate_image( static api::VulkanImage allocate_image(
api::Context* const context_ptr, api::Context* const context_ptr,
api::utils::uvec3& extents, api::utils::uvec3& extents,
const api::StorageType storage_type, const api::StorageType storage_type,
@ -505,7 +505,7 @@ api::VulkanImage allocate_image(
/*allocate_memory = */ allocate_memory); /*allocate_memory = */ allocate_memory);
} }
api::VulkanBuffer allocate_buffer( static api::VulkanBuffer allocate_buffer(
api::Context* const context_ptr, api::Context* const context_ptr,
const int64_t numel, const int64_t numel,
const api::StorageType storage_type, const api::StorageType storage_type,

2
aten/src/ATen/native/vulkan/impl/Packing.cpp
View File

@ -296,7 +296,7 @@ bool record_buffer_to_nchw_op(
v_src.buffer_metadata()); v_src.buffer_metadata());
} }
vTensor channel_image_repacking( static vTensor channel_image_repacking(
const vTensor& v_input, const vTensor& v_input,
api::GPUMemoryLayout target_layout, api::GPUMemoryLayout target_layout,
const api::ShaderInfo& shader_descriptor) { const api::ShaderInfo& shader_descriptor) {

2
aten/src/ATen/native/vulkan/ops/Batchnorm.cpp
View File

@ -15,7 +15,7 @@ struct Params final {
float eps; float eps;
}; };
void record_op( static void record_op(
api::Context* const context, api::Context* const context,
vTensor& v_output, vTensor& v_output,
const vTensor& v_input, const vTensor& v_input,

75
aten/src/ATen/native/vulkan/ops/BinaryOp.cpp
View File

@ -1,9 +1,9 @@
#ifdef USE_VULKAN_API
#include <ATen/ArrayRef.h> #include <ATen/ArrayRef.h>
#include <ATen/native/vulkan/ops/Common.h> #include <ATen/native/vulkan/ops/Common.h>
#include <ATen/native/vulkan/ops/QuantizedFunctions.h> #include <ATen/native/vulkan/ops/QuantizedFunctions.h>
#include <ATen/native/vulkan/ops/Utils.h> #include <ATen/native/vulkan/ops/Utils.h>
#include <torch/library.h> #include <torch/library.h>
#include <vector>
namespace at { namespace at {
namespace native { namespace native {
@ -12,7 +12,7 @@ namespace ops {
using namespace api::utils; using namespace api::utils;
Tensor binary_op_scalar( static Tensor binary_op_scalar(
const Tensor& self_arg, const Tensor& self_arg,
const Scalar& other, const Scalar& other,
const std::optional<Scalar>& alpha_arg, const std::optional<Scalar>& alpha_arg,
@ -66,7 +66,7 @@ Tensor binary_op_scalar(
return convert(v_output); return convert(v_output);
} }
Tensor binary_op_preprocess_other_arg(const Tensor& other_arg) { static Tensor binary_op_preprocess_other_arg(const Tensor& other_arg) {
// Similar to binary_op_scalar where tensors is mapped to float, we // Similar to binary_op_scalar where tensors is mapped to float, we
// also map known integer types (but not quant types) tensor to float. // also map known integer types (but not quant types) tensor to float.
@ -99,7 +99,7 @@ Tensor binary_op_preprocess_other_arg(const Tensor& other_arg) {
return other; return other;
} }
Tensor& binary_op_scalar_( static Tensor& binary_op_scalar_(
Tensor& self_arg, Tensor& self_arg,
const Scalar& other, const Scalar& other,
const std::optional<Scalar>& alpha_arg, const std::optional<Scalar>& alpha_arg,
@ -149,7 +149,7 @@ Tensor& binary_op_scalar_(
return self_arg; return self_arg;
} }
Tensor binary_op_tensor( static Tensor binary_op_tensor(
const Tensor& self_arg, const Tensor& self_arg,
const Tensor& other_arg, const Tensor& other_arg,
const std::optional<Scalar>& alpha_arg, const std::optional<Scalar>& alpha_arg,
@ -222,7 +222,7 @@ Tensor binary_op_tensor(
return convert(v_output); return convert(v_output);
} }
Tensor quantized_binary_op_tensor( static Tensor quantized_binary_op_tensor(
const Tensor& self_arg, const Tensor& self_arg,
const Tensor& other_arg, const Tensor& other_arg,
const double scale, const double scale,
@ -310,7 +310,7 @@ Tensor quantized_binary_op_tensor(
return convert_quantized(v_output); return convert_quantized(v_output);
} }
Tensor& binary_op_tensor_( static Tensor& binary_op_tensor_(
Tensor& self_arg, Tensor& self_arg,
const Tensor& other_arg, const Tensor& other_arg,
const std::optional<Scalar>& alpha_arg, const std::optional<Scalar>& alpha_arg,
@ -384,7 +384,7 @@ Tensor& binary_op_tensor_(
return self_arg; return self_arg;
} }
Tensor add_scalar( static Tensor add_scalar(
const Tensor& self_arg, const Tensor& self_arg,
const Scalar& other, const Scalar& other,
const Scalar& alpha) { const Scalar& alpha) {
@ -392,7 +392,10 @@ Tensor add_scalar(
self_arg, other, std::optional<Scalar>(alpha), VK_KERNEL(add_scalar)); self_arg, other, std::optional<Scalar>(alpha), VK_KERNEL(add_scalar));
} }
Tensor& add_scalar_(Tensor& self, const Scalar& other, const Scalar& alpha) { static Tensor& add_scalar_(
Tensor& self,
const Scalar& other,
const Scalar& alpha) {
return binary_op_scalar_( return binary_op_scalar_(
self, other, std::optional<Scalar>(alpha), VK_KERNEL(add_scalar_inplace)); self, other, std::optional<Scalar>(alpha), VK_KERNEL(add_scalar_inplace));
} }
@ -433,7 +436,7 @@ Tensor quantized_div(
self_arg, other_arg, scale, zero_point, VK_KERNEL(quantized_div)); self_arg, other_arg, scale, zero_point, VK_KERNEL(quantized_div));
} }
Tensor add_tensor( static Tensor add_tensor(
const Tensor& self_arg, const Tensor& self_arg,
const Tensor& other_arg, const Tensor& other_arg,
const Scalar& alpha) { const Scalar& alpha) {
@ -441,7 +444,7 @@ Tensor add_tensor(
self_arg, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(add)); self_arg, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(add));
} }
Tensor& add_tensor_( static Tensor& add_tensor_(
Tensor& self, Tensor& self,
const Tensor& other_arg, const Tensor& other_arg,
const Scalar& alpha) { const Scalar& alpha) {
@ -449,7 +452,7 @@ Tensor& add_tensor_(
self, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(add_inplace)); self, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(add_inplace));
} }
Tensor sub_scalar( static Tensor sub_scalar(
const Tensor& self_arg, const Tensor& self_arg,
const Scalar& other, const Scalar& other,
const Scalar& alpha) { const Scalar& alpha) {
@ -460,7 +463,10 @@ Tensor sub_scalar(
VK_KERNEL(add_scalar)); VK_KERNEL(add_scalar));
} }
Tensor& sub_scalar_(Tensor& self, const Scalar& other, const Scalar& alpha) { static Tensor& sub_scalar_(
Tensor& self,
const Scalar& other,
const Scalar& alpha) {
return binary_op_scalar_( return binary_op_scalar_(
self, self,
other, other,
@ -468,7 +474,7 @@ Tensor& sub_scalar_(Tensor& self, const Scalar& other, const Scalar& alpha) {
VK_KERNEL(add_scalar_inplace)); VK_KERNEL(add_scalar_inplace));
} }
Tensor sub_tensor( static Tensor sub_tensor(
const Tensor& self_arg, const Tensor& self_arg,
const Tensor& other_arg, const Tensor& other_arg,
const Scalar& alpha) { const Scalar& alpha) {
@ -476,7 +482,7 @@ Tensor sub_tensor(
self_arg, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(sub)); self_arg, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(sub));
} }
Tensor& sub_tensor_( static Tensor& sub_tensor_(
Tensor& self, Tensor& self,
const Tensor& other_arg, const Tensor& other_arg,
const Scalar& alpha) { const Scalar& alpha) {
@ -484,27 +490,27 @@ Tensor& sub_tensor_(
self, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(sub_inplace)); self, other_arg, std::optional<Scalar>(alpha), VK_KERNEL(sub_inplace));
} }
Tensor mul_scalar(const Tensor& self_arg, const Scalar& other) { static Tensor mul_scalar(const Tensor& self_arg, const Scalar& other) {
return binary_op_scalar( return binary_op_scalar(
self_arg, other, std::optional<Scalar>(), VK_KERNEL(mul_scalar)); self_arg, other, std::optional<Scalar>(), VK_KERNEL(mul_scalar));
} }
Tensor& mul_scalar_(Tensor& self, const Scalar& other) { static Tensor& mul_scalar_(Tensor& self, const Scalar& other) {
return binary_op_scalar_( return binary_op_scalar_(
self, other, std::optional<Scalar>(), VK_KERNEL(mul_scalar_inplace)); self, other, std::optional<Scalar>(), VK_KERNEL(mul_scalar_inplace));
} }
Tensor mul_tensor(const Tensor& self_arg, const Tensor& other_arg) { static Tensor mul_tensor(const Tensor& self_arg, const Tensor& other_arg) {
return binary_op_tensor( return binary_op_tensor(
self_arg, other_arg, std::optional<Scalar>(), VK_KERNEL(mul)); self_arg, other_arg, std::optional<Scalar>(), VK_KERNEL(mul));
} }
Tensor& mul_tensor_(Tensor& self, const Tensor& other_arg) { static Tensor& mul_tensor_(Tensor& self, const Tensor& other_arg) {
return binary_op_tensor_( return binary_op_tensor_(
self, other_arg, std::optional<Scalar>(), VK_KERNEL(mul_inplace)); self, other_arg, std::optional<Scalar>(), VK_KERNEL(mul_inplace));
} }
Tensor div_scalar(const Tensor& self_arg, const Scalar& other) { static Tensor div_scalar(const Tensor& self_arg, const Scalar& other) {
return binary_op_scalar( return binary_op_scalar(
self_arg, self_arg,
1.0 / other.to<float>(), 1.0 / other.to<float>(),
@ -512,7 +518,7 @@ Tensor div_scalar(const Tensor& self_arg, const Scalar& other) {
VK_KERNEL(mul_scalar)); VK_KERNEL(mul_scalar));
} }
Tensor& div_scalar_(Tensor& self, const Scalar& other) { static Tensor& div_scalar_(Tensor& self, const Scalar& other) {
return binary_op_scalar_( return binary_op_scalar_(
self, self,
1.0 / other.to<float>(), 1.0 / other.to<float>(),
@ -520,31 +526,31 @@ Tensor& div_scalar_(Tensor& self, const Scalar& other) {
VK_KERNEL(mul_scalar_inplace)); VK_KERNEL(mul_scalar_inplace));
} }
Tensor div_tensor(const Tensor& self_arg, const Tensor& other_arg) { static Tensor div_tensor(const Tensor& self_arg, const Tensor& other_arg) {
return binary_op_tensor( return binary_op_tensor(
self_arg, other_arg, std::optional<Scalar>(), VK_KERNEL(div)); self_arg, other_arg, std::optional<Scalar>(), VK_KERNEL(div));
} }
Tensor& div_tensor_(Tensor& self, const Tensor& other_arg) { static Tensor& div_tensor_(Tensor& self, const Tensor& other_arg) {
return binary_op_tensor_( return binary_op_tensor_(
self, other_arg, std::optional<Scalar>(), VK_KERNEL(div_inplace)); self, other_arg, std::optional<Scalar>(), VK_KERNEL(div_inplace));
} }
Tensor pow(const Tensor& self, const Tensor& other) { static Tensor pow(const Tensor& self, const Tensor& other) {
return binary_op_tensor(self, other, std::optional<Scalar>(), VK_KERNEL(pow)); return binary_op_tensor(self, other, std::optional<Scalar>(), VK_KERNEL(pow));
} }
Tensor& pow_(Tensor& self, const Tensor& other) { static Tensor& pow_(Tensor& self, const Tensor& other) {
return binary_op_tensor_( return binary_op_tensor_(
self, other, std::optional<Scalar>(), VK_KERNEL(pow_inplace)); self, other, std::optional<Scalar>(), VK_KERNEL(pow_inplace));
} }
Tensor pow_tensor_scalar(const Tensor& self, const Scalar& other) { static Tensor pow_tensor_scalar(const Tensor& self, const Scalar& other) {
return binary_op_scalar( return binary_op_scalar(
self, other, std::optional<Scalar>(), VK_KERNEL(pow_tensor_scalar)); self, other, std::optional<Scalar>(), VK_KERNEL(pow_tensor_scalar));
} }
Tensor& pow_tensor_scalar_(Tensor& self, const Scalar& other) { static Tensor& pow_tensor_scalar_(Tensor& self, const Scalar& other) {
return binary_op_scalar_( return binary_op_scalar_(
self, self,
other, other,
@ -552,12 +558,12 @@ Tensor& pow_tensor_scalar_(Tensor& self, const Scalar& other) {
VK_KERNEL(pow_tensor_scalar_inplace)); VK_KERNEL(pow_tensor_scalar_inplace));
} }
Tensor pow_scalar_tensor(const Scalar& self, const Tensor& other) { static Tensor pow_scalar_tensor(const Scalar& self, const Tensor& other) {
return binary_op_scalar( return binary_op_scalar(
other, self, std::optional<Scalar>(), VK_KERNEL(pow_scalar_tensor)); other, self, std::optional<Scalar>(), VK_KERNEL(pow_scalar_tensor));
} }
Tensor floor_divide_scalar(const Tensor& self, const Scalar& other) { static Tensor floor_divide_scalar(const Tensor& self, const Scalar& other) {
TORCH_CHECK( TORCH_CHECK(
other.to<float>() != 0.0f, "floor_divide_scalar: can't divide by zero"); other.to<float>() != 0.0f, "floor_divide_scalar: can't divide by zero");
return binary_op_scalar( return binary_op_scalar(
@ -567,7 +573,7 @@ Tensor floor_divide_scalar(const Tensor& self, const Scalar& other) {
VK_KERNEL(floor_mul_scalar)); VK_KERNEL(floor_mul_scalar));
} }
Tensor& floor_divide_scalar_(Tensor& self, const Scalar& other) { static Tensor& floor_divide_scalar_(Tensor& self, const Scalar& other) {
TORCH_CHECK( TORCH_CHECK(
other.to<float>() != 0.0f, "floor_divide_scalar_: can't divide by zero"); other.to<float>() != 0.0f, "floor_divide_scalar_: can't divide by zero");
return binary_op_scalar_( return binary_op_scalar_(
@ -577,12 +583,12 @@ Tensor& floor_divide_scalar_(Tensor& self, const Scalar& other) {
VK_KERNEL(floor_mul_scalar_inplace)); VK_KERNEL(floor_mul_scalar_inplace));
} }
Tensor floor_divide_tensor(const Tensor& self, const Tensor& other) { static Tensor floor_divide_tensor(const Tensor& self, const Tensor& other) {
return binary_op_tensor( return binary_op_tensor(
self, other, std::optional<Scalar>(), VK_KERNEL(floor_divide)); self, other, std::optional<Scalar>(), VK_KERNEL(floor_divide));
} }
Tensor& floor_divide_tensor_(Tensor& self, const Tensor& other_arg) { static Tensor& floor_divide_tensor_(Tensor& self, const Tensor& other_arg) {
return binary_op_tensor_( return binary_op_tensor_(
self, self,
other_arg, other_arg,
@ -590,8 +596,6 @@ Tensor& floor_divide_tensor_(Tensor& self, const Tensor& other_arg) {
VK_KERNEL(floor_divide_inplace)); VK_KERNEL(floor_divide_inplace));
} }
#ifdef USE_VULKAN_API
TORCH_LIBRARY_IMPL(aten, Vulkan, m) { TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
m.impl(TORCH_SELECTIVE_NAME("aten::add.Scalar"), TORCH_FN(add_scalar)); m.impl(TORCH_SELECTIVE_NAME("aten::add.Scalar"), TORCH_FN(add_scalar));
m.impl(TORCH_SELECTIVE_NAME("aten::add_.Scalar"), TORCH_FN(add_scalar_)); m.impl(TORCH_SELECTIVE_NAME("aten::add_.Scalar"), TORCH_FN(add_scalar_));
@ -631,9 +635,8 @@ TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
TORCH_FN(floor_divide_tensor_)); TORCH_FN(floor_divide_tensor_));
} }
#endif /* USE_VULKAN_API */
} // namespace ops } // namespace ops
} // namespace vulkan } // namespace vulkan
} // namespace native } // namespace native
} // namespace at } // namespace at
#endif /* USE_VULKAN_API */

83
aten/src/ATen/native/vulkan/ops/Convolution.cpp
View File

@ -53,7 +53,7 @@ inline bool is_pointwise(const IntArrayRef weight_size) {
return true; return true;
} }
Conv2dMethod determine_method( static Conv2dMethod determine_method(
const IntArrayRef weight_size, const IntArrayRef weight_size,
const IntArrayRef stride, const IntArrayRef stride,
const IntArrayRef padding, const IntArrayRef padding,
@ -359,7 +359,7 @@ struct Params final {
api::utils::vec2 clamp; api::utils::vec2 clamp;
}; };
void record_op( static void record_op(
api::Context* const context, api::Context* const context,
api::ShaderInfo& compute_shader, api::ShaderInfo& compute_shader,
vTensor& v_output, vTensor& v_output,
@ -432,7 +432,7 @@ struct QParams final {
api::utils::vec2 clamp; api::utils::vec2 clamp;
}; };
void record_quantized_op( static void record_quantized_op(
api::Context* const context, api::Context* const context,
api::ShaderInfo& compute_shader, api::ShaderInfo& compute_shader,
vTensor& v_output, vTensor& v_output,
@ -787,56 +787,11 @@ Tensor convolution(
input, c10::make_intrusive<Conv2dPackedContext>(conv_context)); input, c10::make_intrusive<Conv2dPackedContext>(conv_context));
} }
Tensor quantized_convolution(
const Tensor& input,
const Tensor& weight,
const std::optional<Tensor>& bias,
const IntArrayRef stride,
const IntArrayRef padding,
const IntArrayRef dilation,
const bool transposed,
const IntArrayRef output_padding,
const int64_t groups,
const double out_scale,
const int64_t out_zero_point) {
if (transposed) {
return run_tconv2d_context(
input,
c10::make_intrusive<Conv2dPackedContext>(Conv2dPackedContext(
weight,
bias,
stride,
padding,
dilation,
transposed,
false,
output_padding,
groups)));
}
Conv2dPackedContext conv_context = Conv2dPackedContext(
weight,
bias,
stride,
padding,
dilation,
transposed,
true,
output_padding,
groups);
return run_qconv2d_context(
input,
out_scale,
out_zero_point,
c10::make_intrusive<Conv2dPackedContext>(conv_context));
}
} // namespace } // namespace
namespace conv1d { namespace conv1d {
vTensor pack_weights_using_width_packing(const Tensor& weight_arg) { static vTensor pack_weights_using_width_packing(const Tensor& weight_arg) {
Tensor weight = weight_arg; Tensor weight = weight_arg;
if (weight.is_cpu()) { if (weight.is_cpu()) {
@ -862,7 +817,7 @@ vTensor pack_weights_using_width_packing(const Tensor& weight_arg) {
* This is a full implementation. For algorithm details, refer to the shader * This is a full implementation. For algorithm details, refer to the shader
* kernel code. * kernel code.
*/ */
Tensor run_conv1d_context_impl( static Tensor run_conv1d_context_impl(
const Tensor& input_arg, const Tensor& input_arg,
const Tensor& weight_arg, const Tensor& weight_arg,
const std::optional<Tensor>& bias_arg_opt, const std::optional<Tensor>& bias_arg_opt,
@ -1150,7 +1105,7 @@ c10::intrusive_ptr<Conv2dPackedContext> create_qtconv2d_context(
output_max)); output_max));
} }
Tensor run_conv2d_context_impl( static Tensor run_conv2d_context_impl(
const Tensor& input_arg, const Tensor& input_arg,
const c10::intrusive_ptr<Conv2dPackedContext>& conv_context, const c10::intrusive_ptr<Conv2dPackedContext>& conv_context,
double scale, double scale,
@ -1291,30 +1246,6 @@ Tensor run_qconv2d_context(
return run_conv2d_context_impl(input_arg, conv_context, scale, zero_point); return run_conv2d_context_impl(input_arg, conv_context, scale, zero_point);
} }
Tensor quantized_conv2d(
const Tensor& input,
const Tensor& weight,
const std::optional<Tensor>& bias,
IntArrayRef stride,
IntArrayRef padding,
IntArrayRef dilation,
int64_t groups,
double out_scale,
int64_t out_zero_point) {
return quantized_convolution(
input,
weight,
bias,
stride,
padding,
dilation,
false,
{{0, 0}},
groups,
out_scale,
out_zero_point);
}
/* Backwards compatibility */ /* Backwards compatibility */
Conv2dOpContext::Conv2dOpContext(Conv2dPackedContext conv_context) Conv2dOpContext::Conv2dOpContext(Conv2dPackedContext conv_context)
: conv_context_{std::move(conv_context)} {} : conv_context_{std::move(conv_context)} {}
@ -1444,7 +1375,7 @@ c10::intrusive_ptr<Conv1dPackedContext> create_conv1d_context(
Conv1dPackedContext(weight, bias, stride, padding, dilation, groups)); Conv1dPackedContext(weight, bias, stride, padding, dilation, groups));
} }
Tensor convolution1d( static Tensor convolution1d(
const Tensor& input, const Tensor& input,
const Tensor& weight, const Tensor& weight,
const std::optional<Tensor>& bias, const std::optional<Tensor>& bias,

2
aten/src/ATen/native/vulkan/ops/Copy.cpp
View File

@ -123,7 +123,7 @@ void transfer_vulkan_to_cpu(vTensor& v_src, Tensor& dst) {
.to(convert_dtype(v_src.dtype())); .to(convert_dtype(v_src.dtype()));
} }
void transfer_vulkan_to_vulkan(vTensor& src, vTensor& dst) { static void transfer_vulkan_to_vulkan(vTensor& src, vTensor& dst) {
api::Context* const context = api::context(); api::Context* const context = api::context();
api::PipelineBarrier pipeline_barrier{}; api::PipelineBarrier pipeline_barrier{};

4
aten/src/ATen/native/vulkan/ops/Factory.cpp
View File

@ -28,7 +28,7 @@ Tensor _empty_affine_quantized(
}); });
} }
Tensor empty_memory_format( static Tensor empty_memory_format(
const IntArrayRef sizes, const IntArrayRef sizes,
const std::optional<ScalarType> dtype, const std::optional<ScalarType> dtype,
const std::optional<c10::Layout> layout, const std::optional<c10::Layout> layout,
@ -46,7 +46,7 @@ Tensor empty_memory_format(
}); });
} }
Tensor empty_strided( static Tensor empty_strided(
const IntArrayRef sizes, const IntArrayRef sizes,
const IntArrayRef /* strides */, const IntArrayRef /* strides */,
const std::optional<ScalarType> dtype, const std::optional<ScalarType> dtype,

3
aten/src/ATen/native/vulkan/ops/Gru.cpp
View File

@ -135,7 +135,8 @@ TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
} // namespace } // namespace
std::vector<c10::intrusive_ptr<LinearPackedContext>> pack_linear_op_contexts( static std::vector<c10::intrusive_ptr<LinearPackedContext>>
pack_linear_op_contexts(
const std::vector<Tensor>& params_cpu, const std::vector<Tensor>& params_cpu,
int64_t num_layers) { int64_t num_layers) {
TORCH_CHECK( TORCH_CHECK(

2
aten/src/ATen/native/vulkan/ops/Layernorm.cpp
View File

@ -78,7 +78,7 @@ Tensor run_layernorm_context(
return std::get<0>(native_layer_norm_output); return std::get<0>(native_layer_norm_output);
} }
Tensor layer_norm( static Tensor layer_norm(
const at::Tensor& input_arg, const at::Tensor& input_arg,
IntArrayRef normalized_shape, IntArrayRef normalized_shape,
const std::optional<Tensor>& weight_opt /* optional */, const std::optional<Tensor>& weight_opt /* optional */,

2
aten/src/ATen/native/vulkan/ops/Lstm.cpp
View File

@ -171,7 +171,7 @@ TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
} // namespace } // namespace
std::vector<c10::intrusive_ptr<LinearPackedContext>> static std::vector<c10::intrusive_ptr<LinearPackedContext>>
pack_lstm_linear_op_contexts( pack_lstm_linear_op_contexts(
const std::vector<Tensor>& params_cpu, const std::vector<Tensor>& params_cpu,
int64_t num_layers) { int64_t num_layers) {

10
aten/src/ATen/native/vulkan/ops/QuantizedTensor.cpp
View File

@ -1,3 +1,4 @@
#ifdef USE_VULKAN_API
#include <ATen/native/vulkan/ops/Common.h> #include <ATen/native/vulkan/ops/Common.h>
#include <ATen/native/vulkan/ops/QuantizedFunctions.h> #include <ATen/native/vulkan/ops/QuantizedFunctions.h>
#include <ATen/native/vulkan/ops/Utils.h> #include <ATen/native/vulkan/ops/Utils.h>
@ -161,13 +162,13 @@ Tensor dequantize_helper(
return convert(v_output); return convert(v_output);
} }
double q_scale(const Tensor& self) { static double q_scale(const Tensor& self) {
TORCH_CHECK(self.is_vulkan(), "Expecting a vulkan tensor for q_scale"); TORCH_CHECK(self.is_vulkan(), "Expecting a vulkan tensor for q_scale");
const vTensor& v_input = convert(self); const vTensor& v_input = convert(self);
return v_input.get_scale(); return v_input.get_scale();
} }
int64_t q_zero_point(const Tensor& self) { static int64_t q_zero_point(const Tensor& self) {
TORCH_CHECK(self.is_vulkan(), "Expecting a vulkan tensor for q_zero_point"); TORCH_CHECK(self.is_vulkan(), "Expecting a vulkan tensor for q_zero_point");
const vTensor& v_input = convert(self); const vTensor& v_input = convert(self);
return v_input.get_zero_point(); return v_input.get_zero_point();
@ -179,8 +180,6 @@ Tensor dequantize(const Tensor& self) {
return dequantize_helper(self, q_scale, zero_point, kFloat); return dequantize_helper(self, q_scale, zero_point, kFloat);
} }
#ifdef USE_VULKAN_API
TORCH_LIBRARY_IMPL(aten, Vulkan, m) { TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
m.impl( m.impl(
TORCH_SELECTIVE_NAME("aten::quantize_per_tensor"), quantize_per_tensor); TORCH_SELECTIVE_NAME("aten::quantize_per_tensor"), quantize_per_tensor);
@ -192,9 +191,8 @@ TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
m.impl(TORCH_SELECTIVE_NAME("aten::dequantize.self"), dequantize); m.impl(TORCH_SELECTIVE_NAME("aten::dequantize.self"), dequantize);
} }
#endif /* USE_VULKAN_API */
} // namespace ops } // namespace ops
} // namespace vulkan } // namespace vulkan
} // namespace native } // namespace native
} // namespace at } // namespace at
#endif /* USE_VULKAN_API */

12
aten/src/ATen/native/vulkan/ops/Random.cpp
View File

@ -12,7 +12,9 @@ namespace ops {
using namespace api::utils; using namespace api::utils;
Tensor& uniform_( #ifdef USE_VULKAN_API
static Tensor& uniform_(
Tensor& self, Tensor& self,
const double from, const double from,
const double to, const double to,
@ -57,7 +59,7 @@ Tensor& uniform_(
return self; return self;
} }
Tensor rand_like( static Tensor rand_like(
const at::Tensor& input_arg, const at::Tensor& input_arg,
const std::optional<c10::ScalarType> /* not implemented */, const std::optional<c10::ScalarType> /* not implemented */,
const std::optional<c10::Layout> /* not implemented */, const std::optional<c10::Layout> /* not implemented */,
@ -71,7 +73,7 @@ Tensor rand_like(
return input_arg.clone().detach().uniform_(0.0, 1.0); return input_arg.clone().detach().uniform_(0.0, 1.0);
} }
Tensor& normal_( static Tensor& normal_(
Tensor& self, Tensor& self,
const double mean, const double mean,
const double std, const double std,
@ -118,7 +120,7 @@ Tensor& normal_(
return self; return self;
} }
Tensor randn_like( static Tensor randn_like(
const at::Tensor& input_arg, const at::Tensor& input_arg,
const std::optional<c10::ScalarType> /* not implemented */, const std::optional<c10::ScalarType> /* not implemented */,
const std::optional<c10::Layout> /* not implemented */, const std::optional<c10::Layout> /* not implemented */,
@ -130,8 +132,6 @@ Tensor randn_like(
return input_arg.clone().detach().normal_(0.0, 1.0); return input_arg.clone().detach().normal_(0.0, 1.0);
} }
#ifdef USE_VULKAN_API
TORCH_LIBRARY_IMPL(aten, Vulkan, m) { TORCH_LIBRARY_IMPL(aten, Vulkan, m) {
m.impl(TORCH_SELECTIVE_NAME("aten::uniform_"), TORCH_FN(uniform_)); m.impl(TORCH_SELECTIVE_NAME("aten::uniform_"), TORCH_FN(uniform_));
m.impl(TORCH_SELECTIVE_NAME("aten::rand_like"), TORCH_FN(rand_like)); m.impl(TORCH_SELECTIVE_NAME("aten::rand_like"), TORCH_FN(rand_like));

4
aten/src/ATen/native/vulkan/ops/Shape.cpp
View File

@ -8,7 +8,7 @@ namespace native {
namespace vulkan { namespace vulkan {
namespace ops { namespace ops {
Tensor view_internal(const Tensor& self_arg, const IntArrayRef shape) { static Tensor view_internal(const Tensor& self_arg, const IntArrayRef shape) {
api::Context* const context = api::context(); api::Context* const context = api::context();
Tensor self = self_arg.is_vulkan() ? self_arg : self_arg.vulkan(); Tensor self = self_arg.is_vulkan() ? self_arg : self_arg.vulkan();
@ -52,7 +52,7 @@ inline Tensor view(const Tensor& self_arg, IntArrayRef shape) {
return view_internal(self_arg, shape); return view_internal(self_arg, shape);
} }
Tensor _reshape_alias( static Tensor _reshape_alias(
const Tensor& self_arg, const Tensor& self_arg,
const IntArrayRef shape, const IntArrayRef shape,
const IntArrayRef strides) { const IntArrayRef strides) {

4
aten/src/ATen/native/vulkan/ops/Upsample.cpp
View File

@ -9,7 +9,7 @@ namespace vulkan {
namespace ops { namespace ops {
using namespace api::utils; using namespace api::utils;
Tensor upsample_nearest2d( static Tensor upsample_nearest2d(
const Tensor& input_arg, const Tensor& input_arg,
const IntArrayRef output_sizes, const IntArrayRef output_sizes,
const std::optional<double> scales_h, const std::optional<double> scales_h,
@ -94,7 +94,7 @@ Tensor upsample_nearest2d(
return convert(v_output); return convert(v_output);
} }
Tensor upsample_bilinear2d( static Tensor upsample_bilinear2d(
const Tensor& input_arg, const Tensor& input_arg,
const IntArrayRef output_sizes, const IntArrayRef output_sizes,
bool align_corners, bool align_corners,

1
aten/src/ATen/native/vulkan/ops/Utils.cpp
View File

@ -1,5 +1,6 @@
#include <ATen/native/vulkan/impl/Packing.h> #include <ATen/native/vulkan/impl/Packing.h>
#include <ATen/native/vulkan/ops/Common.h> #include <ATen/native/vulkan/ops/Common.h>
#include <ATen/native/vulkan/ops/Utils.h>
#ifndef AT_PER_OPERATOR_HEADERS #ifndef AT_PER_OPERATOR_HEADERS
#include <ATen/Functions.h> #include <ATen/Functions.h>

2
caffe2/CMakeLists.txt
View File

@ -767,7 +767,7 @@ if(NOT MSVC)
set_source_files_properties(${PROJECT_SOURCE_DIR}/torch/csrc/distributed/c10d/socket.cpp PROPERTIES COMPILE_OPTIONS "-Wno-error=deprecated") set_source_files_properties(${PROJECT_SOURCE_DIR}/torch/csrc/distributed/c10d/socket.cpp PROPERTIES COMPILE_OPTIONS "-Wno-error=deprecated")
endif() endif()
if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND NOT USE_VULKAN AND NOT USE_IOS AND NOT USE_COREML_DELEGATE) if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND NOT USE_IOS AND NOT USE_COREML_DELEGATE)
target_compile_options_if_supported(torch_cpu "-Wmissing-prototypes") target_compile_options_if_supported(torch_cpu "-Wmissing-prototypes")
target_compile_options_if_supported(torch_cpu "-Werror=missing-prototypes") target_compile_options_if_supported(torch_cpu "-Werror=missing-prototypes")
get_target_property(TORCH_CPU_SOURCES torch_cpu SOURCES) get_target_property(TORCH_CPU_SOURCES torch_cpu SOURCES)