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

[3/N] Fix clang-tidy warnings in jit (#131830)

Browse Source 
Follows #131735

Pull Request resolved: https://github.com/pytorch/pytorch/pull/131830
Approved by: https://github.com/ezyang
This commit is contained in:
cyy
2024-07-26 15:46:28 +00:00
committed by PyTorch MergeBot
parent 5612408735
commit 2988d33c80
13 changed files with 77 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
torch/csrc/jit/python/init.cpp
View File

@ -420,7 +420,7 @@ void initJITBindings(PyObject* module) {
.def("_jit_pass_optimize_frozen_graph", &OptimizeFrozenGraph)
.def(
"_jit_pass_optimize_for_inference",
[](Module& module, std::vector<std::string> other_methods) {
[](Module& module, const std::vector<std::string>& other_methods) {
optimize_for_inference(module, other_methods);
},
py::arg("module"),
@ -671,7 +671,7 @@ void initJITBindings(PyObject* module) {
})
.def(
"_jit_pass_create_autodiff_subgraphs",
[](const std::shared_ptr<Graph>& graph, py::object threshold) {
[](const std::shared_ptr<Graph>& graph, const py::object& threshold) {
if (threshold.is_none()) {
CreateAutodiffSubgraphs(graph);
} else {
@ -863,7 +863,7 @@ void initJITBindings(PyObject* module) {
})
.def(
"_jit_set_fusion_strategy",
[](std::vector<std::pair<std::string, size_t>> strategy) {
[](const std::vector<std::pair<std::string, size_t>>& strategy) {
FusionStrategy vec_conv;
for (const auto& pair : strategy) {
if (pair.first == "STATIC") {
@ -900,18 +900,18 @@ void initJITBindings(PyObject* module) {
.def(
"_jit_set_logging_option",
[](std::string loggingOption) -> void {
::torch::jit::set_jit_logging_levels(loggingOption);
::torch::jit::set_jit_logging_levels(std::move(loggingOption));
})
.def(
"_jit_set_logging_stream",
[](std::string stream_name) -> void {
[](const std::string& stream_name) -> void {
if (stream_name == "stdout") {
::torch::jit::set_jit_logging_output_stream(std::cout);
} else if (stream_name == "stderr") {
::torch::jit::set_jit_logging_output_stream(std::cerr);
} else {
std::cerr << "ERROR: only `stdout` and `stderr`"
<< "are supported as output options" << std::endl;
<< "are supported as output options" << '\n';
}
})
.def(
@ -1173,13 +1173,13 @@ void initJITBindings(PyObject* module) {
// NB: This isn't actually used for regular PyTorch symbolic tracing;
// XLA is what needs this
#define SYMNODE_UNARY(n) .def(#n, [](c10::SymNode a) { return a->n(); })
#define SYMNODE_UNARY(n) .def(#n, [](const c10::SymNode& a) { return a->n(); })
#define SYMNODE_BINARY(n) \
.def(#n, [](c10::SymNode a, c10::SymNode b) { return a->n(b); })
.def(#n, [](const c10::SymNode& a, const c10::SymNode& b) { return a->n(b); })
#define SYMNODE_SIZES_STRIDES(n) \
.def( \
#n, \
[](c10::SymNode a, \
[](const c10::SymNode& a, \
c10::ArrayRef<c10::SymNode> sizes, \
c10::ArrayRef<c10::SymNode> strides) { \
return a->n(sizes, strides); \
@ -1230,63 +1230,63 @@ void initJITBindings(PyObject* module) {
SYMNODE_SIZES_STRIDES(is_non_overlapping_and_dense)
.def(
"guard_int",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->guard_int(file, line);
})
.def(
"guard_bool",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->guard_bool(file, line);
})
.def(
"guard_float",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->guard_float(file, line);
})
.def(
"expect_true",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->expect_true(file, line);
})
.def(
"expect_size",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->expect_size(file, line);
})
.def(
"guard_size_oblivious",
[](c10::SymNode a, const char* file, int64_t line) {
[](const c10::SymNode& a, const char* file, int64_t line) {
return a->guard_size_oblivious(file, line);
})
.def(
"has_hint",
[](c10::SymNode a) {
[](const c10::SymNode& a) {
return a->has_hint();
})
.def(
"wrap_int",
[](c10::SymNode a, int64_t b) {
[](const c10::SymNode& a, int64_t b) {
return a->wrap_int(b);
})
.def(
"wrap_float",
[](c10::SymNode a, double b) {
[](const c10::SymNode& a, double b) {
return a->wrap_float(b);
})
.def(
"wrap_bool",
[](c10::SymNode a, bool b) {
[](const c10::SymNode& a, bool b) {
return a->wrap_bool(b);
})
.def(
"__str__",
[](c10::SymNode a) { return a->str(); })
[](const c10::SymNode& a) { return a->str(); })
.def(
"__repr__",
[](c10::SymNode a) { return a->str(); })
[](const c10::SymNode& a) { return a->str(); })
.def(
"_graph_repr",
[](c10::SymNode a) { return a->_graph_repr(); })
[](const c10::SymNode& a) { return a->_graph_repr(); })
.def(
"is_constant",
[](const c10::SymNode& node){
@ -1455,7 +1455,7 @@ void initJITBindings(PyObject* module) {
"write_record",
[](PyTorchStreamWriter& self,
const std::string& name,
c10::Storage data,
const c10::Storage& data,
size_t size) {
// Reading Tensor data is always ok without the GIL held
py::gil_scoped_release release;
@ -1507,8 +1507,8 @@ void initJITBindings(PyObject* module) {
buffer.attr("seek")(current, py::module::import("os").attr("SEEK_END"));
size_ = py::cast<size_t>(buffer.attr("tell")()) - start_offset_;
buffer.attr("seek")(current);
// If we can read directly into a buffer, do that instead of an extra copy
// NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
use_readinto_ = py::hasattr(buffer, "readinto");
}
@ -1557,7 +1557,7 @@ void initJITBindings(PyObject* module) {
py::object buffer_;
size_t size_;
size_t start_offset_;
bool use_readinto_;
bool use_readinto_{};
};
py::class_<PyTorchStreamReader, std::shared_ptr<PyTorchStreamReader>>(
@ -1673,16 +1673,18 @@ void initJITBindings(PyObject* module) {
bool allow_numbers_as_tensors = opAllowsNumbersAsTensors(symbol);
for (const auto& op : operations) {
if (op->schema().overload_name() == overload_name) {
auto func =
py::cpp_function([op, symbol, allow_numbers_as_tensors](
py::args args, py::kwargs kwargs) {
auto func = py::cpp_function(
[op, symbol, allow_numbers_as_tensors](
const py::args& args, const py::kwargs& kwargs) {
ToIValueAllowNumbersAsTensors g(allow_numbers_as_tensors);
return _get_operation_for_overload_or_packet(
{op}, symbol, args, kwargs, /*is_overload*/ true);
});
auto func_dk = py::cpp_function(
[op, symbol, allow_numbers_as_tensors](
c10::DispatchKey dk_, py::args args, py::kwargs kwargs) {
auto func_dk =
py::cpp_function([op, symbol, allow_numbers_as_tensors](
c10::DispatchKey dk_,
const py::args& args,
const py::kwargs& kwargs) {
std::optional<c10::DispatchKey> dk =
std::make_optional(dk_);
ToIValueAllowNumbersAsTensors g(allow_numbers_as_tensors);
@ -1704,7 +1706,9 @@ void initJITBindings(PyObject* module) {
m.def(
"_check_schema_allow_fake_script_object",
[](const FunctionSchema& schema, py::args args, py::kwargs kwargs) {
[](const FunctionSchema& schema,
const py::args& args,
const py::kwargs& kwargs) {
// checkSchemaAllowFakeScriptObject will throw runtime error if there is
// a schema mismatch. Otherwise, it returns true.
return checkSchemaAllowFakeScriptObject(schema, args, kwargs);
@ -1712,16 +1716,16 @@ void initJITBindings(PyObject* module) {
m.def(
"_jit_resolve_packet",
[](const char* op_name, py::args args, py::kwargs kwargs) {
[](const char* op_name, py::args args, const py::kwargs& kwargs) {
try {
auto symbol = Symbol::fromQualString(op_name);
bool allow_numbers_as_tensors = opAllowsNumbersAsTensors(symbol);
ToIValueAllowNumbersAsTensors g(allow_numbers_as_tensors);
const auto overloads = getAllSortedOperatorsFor(symbol);
auto opWithStack = getOpWithStack(overloads, args, kwargs);
auto opWithStack = getOpWithStack(overloads, std::move(args), kwargs);
std::shared_ptr<Operator> overload = std::get<0>(opWithStack);
auto result = overload->schema().overload_name();
if (result == "") {
if (result.empty()) {
result = "default";
}
return result;
@ -1761,7 +1765,7 @@ void initJITBindings(PyObject* module) {
auto func = py::cpp_function(
[sortedOps, symbol, allow_numbers_as_tensors](
py::args args, py::kwargs kwargs) {
const py::args& args, const py::kwargs& kwargs) {
ToIValueAllowNumbersAsTensors g(allow_numbers_as_tensors);
return _get_operation_for_overload_or_packet(
sortedOps, symbol, args, kwargs, false);
@ -1780,7 +1784,9 @@ void initJITBindings(PyObject* module) {
m.def(
"_maybe_call_torch_function_for_op_packet",
[](py::handle op_overload_packet, py::args args, py::kwargs kwargs) {
[](py::handle op_overload_packet,
const py::args& args,
const py::kwargs& kwargs) {
py::list ns_method =
op_overload_packet.attr("_qualified_op_name").attr("split")("::");
auto res = _maybe_handle_torch_function(
@ -1950,7 +1956,7 @@ void initJITBindings(PyObject* module) {
ss << self;
return py::str(ss.str());
},
[](py::str schema) { // __setstate__, note: no `self` argument
[](const py::str& schema) { // __setstate__, note: no `self` argument
return parseSchema(schema);
}))
.def_property_readonly(
@ -2146,7 +2152,7 @@ void initJITBindings(PyObject* module) {
return self_value->overlaps(*other_value);
});
m.def("_awaitable", [](const py::args& args, const py::kwargs& kwargs) {
AT_ASSERT(args.size() >= 1);
AT_ASSERT(!args.empty());
py::tuple args_tup(args.size() - 1);
for (const auto i : c10::irange(1, args.size())) {
args_tup[i - 1] = args[i];
@ -2155,7 +2161,7 @@ void initJITBindings(PyObject* module) {
py::cast<py::function>(args[0]), std::move(args_tup));
});
m.def("_awaitable_nowait", [](py::handle input) {
return std::make_shared<PythonAwaitWrapper>(std::move(input));
return std::make_shared<PythonAwaitWrapper>(input);
});
m.def(
"_awaitable_wait", [](const std::shared_ptr<PythonAwaitWrapper>& py_aw) {