diff --git a/paddle/memory/.clang-format b/paddle/memory/.clang-format deleted file mode 100644 index 29282dc87e2c499988c17d90d47d44cd5cf7f115..0000000000000000000000000000000000000000 --- a/paddle/memory/.clang-format +++ /dev/null @@ -1,5 +0,0 @@ ---- -Language: Cpp -BasedOnStyle: Google -Standard: Cpp11 -... diff --git a/paddle/memory/.clang-format b/paddle/memory/.clang-format new file mode 120000 index 0000000000000000000000000000000000000000..7d28cb3924707d39dafe20f4664fb17b5538996c --- /dev/null +++ b/paddle/memory/.clang-format @@ -0,0 +1 @@ +../framework/.clang-format \ No newline at end of file diff --git a/paddle/operators/.clang-format b/paddle/operators/.clang-format deleted file mode 100644 index 47b8a85206ab457e2b3cb90a68b7a82a0753d327..0000000000000000000000000000000000000000 --- a/paddle/operators/.clang-format +++ /dev/null @@ -1,5 +0,0 @@ ---- -Language: Cpp -BasedOnStyle: Google -Standard: Cpp11 -... diff --git a/paddle/operators/.clang-format b/paddle/operators/.clang-format new file mode 120000 index 0000000000000000000000000000000000000000..7d28cb3924707d39dafe20f4664fb17b5538996c --- /dev/null +++ b/paddle/operators/.clang-format @@ -0,0 +1 @@ +../framework/.clang-format \ No newline at end of file diff --git a/paddle/pybind/.clang-format b/paddle/pybind/.clang-format new file mode 120000 index 0000000000000000000000000000000000000000..7d28cb3924707d39dafe20f4664fb17b5538996c --- /dev/null +++ b/paddle/pybind/.clang-format @@ -0,0 +1 @@ +../framework/.clang-format \ No newline at end of file diff --git a/paddle/pybind/protobuf.cc b/paddle/pybind/protobuf.cc index de3f7bb97be9787e0e9b0130a87d19529edf44f3..1a29621bdf13030c8781dab4acccca08d7250dbe 100644 --- a/paddle/pybind/protobuf.cc +++ b/paddle/pybind/protobuf.cc @@ -46,8 +46,7 @@ struct variant_caster> { template typename std::enable_if< - !std::is_same::value, - bool>::type + !std::is_same::value, bool>::type try_load(handle src, bool convert) { auto caster = make_caster(); if (!load_success_ && caster.load(src, convert)) { @@ -71,8 +70,7 @@ struct variant_caster> { return load_success_; } - static handle cast(Type const &src, - return_value_policy policy, + static handle cast(Type const &src, return_value_policy policy, handle parent) { variant_caster_visitor visitor(policy, parent); return boost::apply_visitor(visitor, src); @@ -101,8 +99,8 @@ inline std::vector RepeatedToVector( const google::protobuf::RepeatedField &repeated_field) { std::vector ret; ret.reserve(repeated_field.size()); - std::copy( - repeated_field.begin(), repeated_field.end(), std::back_inserter(ret)); + std::copy(repeated_field.begin(), repeated_field.end(), + std::back_inserter(ret)); return ret; } @@ -134,7 +132,7 @@ class VarDescBind; // read/write speed. Only when we want the protobuf message, the local changes // will be synchronized (by `Sync` method). class VarDescBind { -public: + public: explicit VarDescBind(const std::string &name) { desc_.set_name(name); } VarDesc *Proto() { return &desc_; } @@ -157,12 +155,12 @@ public: return desc_.lod_tensor().data_type(); } -private: + private: VarDesc desc_; }; class OpDescBind { -public: + public: OpDesc *Proto() { Sync(); return &op_desc_; @@ -174,8 +172,8 @@ public: const std::vector &Input(const std::string &name) const { auto it = inputs_.find(name); - PADDLE_ENFORCE( - it != inputs_.end(), "Input %s cannot be found in Op %s", name, Type()); + PADDLE_ENFORCE(it != inputs_.end(), "Input %s cannot be found in Op %s", + name, Type()); return it->second; } @@ -196,10 +194,8 @@ public: const std::vector &Output(const std::string &name) const { auto it = outputs_.find(name); - PADDLE_ENFORCE(it != outputs_.end(), - "Output %s cannot be found in Op %s", - name, - Type()); + PADDLE_ENFORCE(it != outputs_.end(), "Output %s cannot be found in Op %s", + name, Type()); return it->second; } @@ -258,7 +254,7 @@ public: return boost::get(it->second)->idx(); } -private: + private: struct SetAttrDescVisitor : public boost::static_visitor { explicit SetAttrDescVisitor(OpDesc::Attr *attr) : attr_(attr) {} mutable OpDesc::Attr *attr_; @@ -325,7 +321,7 @@ private: }; class BlockDescBind { -public: + public: BlockDescBind(ProgramDescBind *prog, BlockDesc *desc) : prog_(prog), desc_(desc), need_update_(false) {} @@ -349,8 +345,8 @@ public: VarDescBind *Var(py::bytes name_bytes) const { std::string name = name_bytes; auto it = vars_.find(name); - PADDLE_ENFORCE( - it != vars_.end(), "Can not find variable %s in current block.", name); + PADDLE_ENFORCE(it != vars_.end(), + "Can not find variable %s in current block.", name); return it->second.get(); } @@ -398,7 +394,7 @@ public: BlockDesc *RawPtr() { return desc_; } -private: + private: ProgramDescBind *prog_; // not_own BlockDesc *desc_; // not_own bool need_update_; @@ -412,7 +408,7 @@ using ProgDescMap = static ProgDescMap *g_bind_map = nullptr; class ProgramDescBind { -public: + public: static ProgramDescBind &Instance(ProgramDesc *prog) { if (g_bind_map == nullptr) { g_bind_map = new ProgDescMap(); @@ -449,7 +445,7 @@ public: return prog_; } -private: + private: explicit ProgramDescBind(ProgramDesc *prog) : prog_(prog) { for (auto &block : *prog->mutable_blocks()) { blocks_.emplace_back(new BlockDescBind(this, &block)); @@ -492,8 +488,7 @@ void BindProgramDesc(py::module &m) { return &ProgramDescBind::Instance(prog_desc); }, py::return_value_policy::reference) - .def("append_block", - &ProgramDescBind::AppendBlock, + .def("append_block", &ProgramDescBind::AppendBlock, py::return_value_policy::reference) .def("block", &ProgramDescBind::Block, py::return_value_policy::reference) .def("__str__", &ProgramDescBind::DebugString) @@ -504,20 +499,16 @@ void BindBlockDesc(py::module &m) { py::class_(m, "BlockDesc", "") .def_property_readonly("id", &BlockDescBind::ID) .def_property_readonly("parent", &BlockDescBind::Parent) - .def("append_op", - &BlockDescBind::AppendOp, + .def("append_op", &BlockDescBind::AppendOp, py::return_value_policy::reference) - .def("prepend_op", - &BlockDescBind::PrependOp, + .def("prepend_op", &BlockDescBind::PrependOp, + py::return_value_policy::reference) + .def("new_var", &BlockDescBind::NewVar, py::return_value_policy::reference) - .def( - "new_var", &BlockDescBind::NewVar, py::return_value_policy::reference) .def("var", &BlockDescBind::Var, py::return_value_policy::reference) - .def("all_vars", - &BlockDescBind::AllVars, + .def("all_vars", &BlockDescBind::AllVars, py::return_value_policy::reference) - .def("all_ops", - &BlockDescBind::AllOps, + .def("all_ops", &BlockDescBind::AllOps, py::return_value_policy::reference); } diff --git a/paddle/pybind/pybind.cc b/paddle/pybind/pybind.cc index df9ebaa2438e271f416bdb02ec2c439c679a21fe..11c1578e6aead6e256082c487a86fb9afa0e1fc2 100644 --- a/paddle/pybind/pybind.cc +++ b/paddle/pybind/pybind.cc @@ -161,8 +161,7 @@ All parameter, weight, gradient are variables in Paddle. py::return_value_policy::reference) .def("find_var", &Scope::FindVar, py::return_value_policy::reference) .def(py::init<>()) - .def("new_scope", - [](Scope &self) -> Scope * { return &self.NewScope(); }, + .def("new_scope", [](Scope &self) -> Scope * { return &self.NewScope(); }, py::return_value_policy::reference) .def("drop_kids", &Scope::DropKids); @@ -230,8 +229,7 @@ All parameter, weight, gradient are variables in Paddle. }) .def("infer_shape", &OperatorBase::InferShape) .def("run", - [](OperatorBase &self, - const Scope &scope, + [](OperatorBase &self, const Scope &scope, const platform::DeviceContext &dev_ctx) { self.Run(scope, dev_ctx); dev_ctx.Wait(); @@ -259,10 +257,8 @@ All parameter, weight, gradient are variables in Paddle. retv->SetType("plain_net"); return retv; }) - .def("append_op", - [](operators::NetOp &self, const OperatorBase &op) { - self.AppendOp(op); - }) + .def("append_op", [](operators::NetOp &self, + const OperatorBase &op) { self.AppendOp(op); }) .def("complete_add_op", &operators::NetOp::CompleteAddOp) .def("complete_add_op", [](std::shared_ptr &self) { self->CompleteAddOp(); @@ -282,9 +278,10 @@ All parameter, weight, gradient are variables in Paddle. auto rnn_op = OpRegistry::CreateOp(desc); return static_cast(rnn_op.release()); }) - .def("set_stepnet", - [](operators::RecurrentOp &self, const operators::NetOp &net) - -> void { self.set_stepnet(net.Clone()); }); + .def("set_stepnet", [](operators::RecurrentOp &self, + const operators::NetOp &net) -> void { + self.set_stepnet(net.Clone()); + }); // cond_op py::class_(m, "CondOp") diff --git a/paddle/pybind/tensor_py.h b/paddle/pybind/tensor_py.h index bcfba84a1aa6e646cf255dc4612dfda42169fc44..f0d5a6f9ff963ecd80d0c261daff56bff50663d4 100644 --- a/paddle/pybind/tensor_py.h +++ b/paddle/pybind/tensor_py.h @@ -63,11 +63,8 @@ struct CastToPyBufferImpl { } return py::buffer_info( dst_tensor.mutable_data(dst_tensor.holder_->place()), - sizeof(CUR_TYPE), - py::format_descriptor::format(), - (size_t)framework::arity(dst_tensor.dims()), - dims_outside, - strides); + sizeof(CUR_TYPE), py::format_descriptor::format(), + (size_t)framework::arity(dst_tensor.dims()), dims_outside, strides); } else { constexpr bool less = I + 1 < std::tuple_size>::value; return CastToPyBufferImpl()(tensor); @@ -110,8 +107,8 @@ void PyCUDATensorSetFromArray( self.Resize(framework::make_ddim(dims)); auto *dst = self.mutable_data(place); - paddle::platform::GpuMemcpySync( - dst, array.data(), sizeof(T) * array.size(), cudaMemcpyHostToDevice); + paddle::platform::GpuMemcpySync(dst, array.data(), sizeof(T) * array.size(), + cudaMemcpyHostToDevice); } #endif diff --git a/paddle/string/.clang-format b/paddle/string/.clang-format new file mode 120000 index 0000000000000000000000000000000000000000..7d28cb3924707d39dafe20f4664fb17b5538996c --- /dev/null +++ b/paddle/string/.clang-format @@ -0,0 +1 @@ +../framework/.clang-format \ No newline at end of file diff --git a/paddle/string/piece.h b/paddle/string/piece.h index 03ae9243a4cc4e9e92e376bf46ab2b1d7162dfcb..7362ce02c7c80e121218fab77d87696403b1c5e8 100644 --- a/paddle/string/piece.h +++ b/paddle/string/piece.h @@ -30,7 +30,7 @@ namespace string { // its syntax is simple as it doesn't own/manage the string, it is // cheap to construct Pieces and pass them around. class Piece { -public: + public: static const size_t npos = static_cast(-1); // We provide non-explicit singleton constructors so users can @@ -57,7 +57,7 @@ public: // Return a string that contains the copy of the referenced data. std::string ToString() const { return std::string(data_, size_); } -private: + private: const char* data_; size_t size_; diff --git a/paddle/string/printf_test.cc b/paddle/string/printf_test.cc index d8f2454165d741b3937f908dcfd87501940750d5..2586264046a2e2ba24b0908c1f6eba163cdef448 100644 --- a/paddle/string/printf_test.cc +++ b/paddle/string/printf_test.cc @@ -11,6 +11,6 @@ TEST(StringPrintf, StringPrintf) { long hour = 14; int min = 44; EXPECT_EQ(std::string("Wednesday, July 27, 14:44"), - paddle::string::Sprintf( - "%s, %s %d, %.2d:%.2d", weekday, month, day, hour, min)); + paddle::string::Sprintf("%s, %s %d, %.2d:%.2d", weekday, month, day, + hour, min)); } diff --git a/paddle/string/tinyformat/tinyformat.h b/paddle/string/tinyformat/tinyformat.h index f0e5e0160fb018b813c1dade727da2861a295147..3516777d9f9669c1e1300b9136c26e61f65b14a7 100644 --- a/paddle/string/tinyformat/tinyformat.h +++ b/paddle/string/tinyformat/tinyformat.h @@ -133,7 +133,7 @@ namespace detail { // Test whether type T1 is convertible to type T2 template struct is_convertible { -private: + private: // two types of different size struct fail { char dummy[2]; @@ -146,7 +146,7 @@ private: static succeed tryConvert(const T2 &); static const T1 &makeT1(); -public: + public: // Standard trick: the (...) version of tryConvert will be chosen from // the overload set only if the version taking a T2 doesn't match. // Then we compare the sizes of the return types to check which @@ -156,8 +156,7 @@ public: // Format the value by casting to type fmtT. This default implementation // should never be called. -template ::value> struct formatValueAsType { static void invoke(std::ostream & /*out*/, const T & /*value*/) { assert(0); } @@ -227,11 +226,8 @@ TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char) /// operator<< to format the type T, with special cases for the %c and %p /// conversions. template -inline void formatValue(std::ostream &out, - const char * /*fmtBegin*/, - const char *fmtEnd, - int ntrunc, - const T &value) { +inline void formatValue(std::ostream &out, const char * /*fmtBegin*/, + const char *fmtEnd, int ntrunc, const T &value) { // The mess here is to support the %c and %p conversions: if these // conversions are active we try to convert the type to a char or const // void* respectively and format that instead of the value itself. For the @@ -253,25 +249,22 @@ inline void formatValue(std::ostream &out, } // Overloaded version for char types to support printing as an integer -#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \ - inline void formatValue(std::ostream &out, \ - const char * /*fmtBegin*/, \ - const char *fmtEnd, \ - int /**/, \ - charType value) { \ - switch (*(fmtEnd - 1)) { \ - case 'u': \ - case 'd': \ - case 'i': \ - case 'o': \ - case 'X': \ - case 'x': \ - out << static_cast(value); \ - break; \ - default: \ - out << value; \ - break; \ - } \ +#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \ + inline void formatValue(std::ostream &out, const char * /*fmtBegin*/, \ + const char *fmtEnd, int /**/, charType value) { \ + switch (*(fmtEnd - 1)) { \ + case 'u': \ + case 'd': \ + case 'i': \ + case 'o': \ + case 'X': \ + case 'x': \ + out << static_cast(value); \ + break; \ + default: \ + out << value; \ + break; \ + } \ } // per 3.9.1: char, signed char and unsigned char are all distinct types TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char) @@ -468,7 +461,7 @@ namespace detail { // each argument to be allocated as a homogenous array inside FormatList // whereas a naive implementation based on inheritance does not. class FormatArg { -public: + public: FormatArg() {} template @@ -477,22 +470,17 @@ public: m_formatImpl(&formatImpl), m_toIntImpl(&toIntImpl) {} - void format(std::ostream &out, - const char *fmtBegin, - const char *fmtEnd, + void format(std::ostream &out, const char *fmtBegin, const char *fmtEnd, int ntrunc) const { m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); } int toInt() const { return m_toIntImpl(m_value); } -private: + private: template - static void formatImpl(std::ostream &out, - const char *fmtBegin, - const char *fmtEnd, - int ntrunc, - const void *value) { + static void formatImpl(std::ostream &out, const char *fmtBegin, + const char *fmtEnd, int ntrunc, const void *value) { formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); } @@ -502,11 +490,8 @@ private: } const void *m_value; - void (*m_formatImpl)(std::ostream &out, - const char *fmtBegin, - const char *fmtEnd, - int ntrunc, - const void *value); + void (*m_formatImpl)(std::ostream &out, const char *fmtBegin, + const char *fmtEnd, int ntrunc, const void *value); int (*m_toIntImpl)(const void *value); }; @@ -555,12 +540,10 @@ inline const char *printFormatStringLiteral(std::ostream &out, // necessary to pull out variable width and precision . The function returns a // pointer to the character after the end of the current format spec. inline const char *streamStateFromFormat(std::ostream &out, - bool &spacePadPositive, - int &ntrunc, + bool &spacePadPositive, int &ntrunc, const char *fmtStart, const detail::FormatArg *formatters, - int &argIndex, - int numFormatters) { + int &argIndex, int numFormatters) { if (*fmtStart != '%') { TINYFORMAT_ERROR( "tinyformat: Not enough conversion specifiers in format string"); @@ -736,10 +719,8 @@ inline const char *streamStateFromFormat(std::ostream &out, } //------------------------------------------------------------------------------ -inline void formatImpl(std::ostream &out, - const char *fmt, - const detail::FormatArg *formatters, - int numFormatters) { +inline void formatImpl(std::ostream &out, const char *fmt, + const detail::FormatArg *formatters, int numFormatters) { // Saved stream state std::streamsize origWidth = out.width(); std::streamsize origPrecision = out.precision(); @@ -751,13 +732,9 @@ inline void formatImpl(std::ostream &out, fmt = printFormatStringLiteral(out, fmt); bool spacePadPositive = false; int ntrunc = -1; - const char *fmtEnd = streamStateFromFormat(out, - spacePadPositive, - ntrunc, - fmt, - formatters, - argIndex, - numFormatters); + const char *fmtEnd = + streamStateFromFormat(out, spacePadPositive, ntrunc, fmt, formatters, + argIndex, numFormatters); if (argIndex >= numFormatters) { // Check args remain after reading any variable width/precision TINYFORMAT_ERROR("tinyformat: Not enough format arguments"); @@ -806,15 +783,14 @@ inline void formatImpl(std::ostream &out, /// information has been stripped from the arguments, leaving just enough of a /// common interface to perform formatting as required. class FormatList { -public: + public: FormatList(detail::FormatArg *formatters, int N) : m_formatters(formatters), m_N(N) {} - friend void vformat(std::ostream &out, - const char *fmt, + friend void vformat(std::ostream &out, const char *fmt, const FormatList &list); -private: + private: const detail::FormatArg *m_formatters; int m_N; }; @@ -827,7 +803,7 @@ namespace detail { // Format list subclass with fixed storage to avoid dynamic allocation template class FormatListN : public FormatList { -public: + public: template FormatListN(const Args &... args) : FormatList(&m_formatterStore[0], N), @@ -835,14 +811,14 @@ public: static_assert(sizeof...(args) == N, "Number of args must be N"); } -private: + private: FormatArg m_formatterStore[N]; }; // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard template <> class FormatListN<0> : public FormatList { -public: + public: FormatListN() : FormatList(0, 0) {} }; diff --git a/paddle/string/to_string_test.cc b/paddle/string/to_string_test.cc index 5ff1b007f1875c7b920a08bd13b8d98cdc5138d3..542c771a98ec8ae187cd4f821ed1ee4373427041 100644 --- a/paddle/string/to_string_test.cc +++ b/paddle/string/to_string_test.cc @@ -17,7 +17,7 @@ constexpr char kOutputString[] = "User Defined Output"; class UserDefinedClass { -public: + public: }; std::ostream& operator<<(std::ostream& s, const UserDefinedClass& ins) {