add clang-format clang-tidy hook

.pre-commit-config.yaml

@@ -20,11 +20,20 @@ repos:
     -   id: trailing-whitespace
         files: (src).*\.(md|py|mm|swift|java|c|cc|cxx|cpp|cu|h|hpp|hxx)$
 
+-   repo: local
+    hooks:
+    -   id: clang-format
+        name: clang-format
+        description: Format files with ClangFormat.
+        entry: bash ./tools/pre-commit.hooks/.clang-format.hook -i
+        language: system
+        files: \.(c|cc|cxx|cpp|h|hpp|hxx)$
+
 -   repo: local
     hooks:
     -   id: clang-tidy
         name: clang-tidy
-        description: Format files with tidy.
+        description: Check C++ code style using clang-tidy.
         entry: bash ./tools/pre-commit.hooks/.clang-tidy.hook -i
         language: system
         files: (src).*\.(c|cc|cxx|cpp|h|hpp|hxx)$

src/common/log.h

@@ -27,7 +27,7 @@ SOFTWARE.
 
 namespace paddle_mobile {
 
-    enum LogLevel {
+enum LogLevel {
     kNO_LOG,
     kLOG_ERROR,
     kLOG_WARNING,
@@ -37,18 +37,18 @@ namespace paddle_mobile {
     kLOG_DEBUG2,
     kLOG_DEBUG3,
     kLOG_DEBUG4
-    };
+};
 
-    // log level
-    static LogLevel log_level = kLOG_DEBUG4;
+// log level
+static LogLevel log_level = kLOG_DEBUG4;
 
-    static std::vector<std::string> logs{"NO",      "ERROR ",  "WARNING",
+static std::vector<std::string> logs{"NO",      "ERROR ",  "WARNING",
                                      "INFO   ", "DEBUG  ", "DEBUG1 ",
                                      "DEBUG2 ", "DEBUG3 ", "DEBUG4 "};
-    struct ToLog;
-    struct Print;
+struct ToLog;
+struct Print;
 
-    struct Print {
+struct Print {
     friend struct ToLog;
 
     template <typename T> Print &operator<<(T const &value) {
@@ -66,9 +66,9 @@ namespace paddle_mobile {
         }
     }
     std::ostringstream buffer_;
-    };
+};
 
-    struct ToLog {
+struct ToLog {
     ToLog(LogLevel level = kLOG_DEBUG, const std::string &info = "")
         : level_(level) {
         unsigned blanks =
@@ -87,16 +87,16 @@ namespace paddle_mobile {
   private:
     LogLevel level_;
     Print printer_;
-    };
+};
 
 #define LOG(level)                                                             \
     if (level > paddle_mobile::log_level) {                                    \
     } else                                                                     \
         paddle_mobile::ToLog(                                                  \
-        level,                                                                 \
-        (std::stringstream()                                                   \
+            level, (std::stringstream()                                        \
                     << "[file: "                                               \
-         << (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__) \
+                    << (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1)  \
+                                               : __FILE__)                     \
                     << "] [line: " << __LINE__ << "] ")                        \
                        .str())
 
@@ -107,10 +107,11 @@ namespace paddle_mobile {
             paddle_mobile::kLOG_DEBUG,                                         \
             (std::stringstream()                                               \
              << "[file: "                                                      \
-         << (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__) \
+             << (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1)         \
+                                        : __FILE__)                            \
              << "] [line: " << __LINE__ << "] ")                               \
                 .str())
-}
+} // namespace paddle_mobile
 
 #define LOGF(level, format, ...)                                               \
     if (level > paddle_mobile::log_level) {                                    \
@@ -126,7 +127,7 @@ namespace paddle_mobile {
 
 namespace paddle_mobile {
 
-    enum LogLevel {
+enum LogLevel {
     kNO_LOG,
     kLOG_ERROR,
     kLOG_WARNING,
@@ -136,23 +137,21 @@ namespace paddle_mobile {
     kLOG_DEBUG2,
     kLOG_DEBUG3,
     kLOG_DEBUG4
-    };
+};
 
-    struct ToLog;
-    struct Print {
+struct ToLog;
+struct Print {
     friend struct ToLog;
     template <typename T> Print &operator<<(T const &value) {}
 
   private:
-    };
+};
 
-    struct ToLog {
+struct ToLog {
     ToLog(LogLevel level) {}
 
-        template <typename T> ToLog &operator<<(T const &value) {
-            return *this;
-        }
-    };
+    template <typename T> ToLog &operator<<(T const &value) { return *this; }
+};
 
 #define LOG(level)                                                             \
     if (true) {                                                                \
@@ -167,6 +166,6 @@ namespace paddle_mobile {
 #define LOGF(level, format, ...)
 
 #define DLOGF(format, ...)
-}
+} // namespace paddle_mobile
 
 #endif

src/common/type_define.h

@@ -24,30 +24,29 @@ SOFTWARE.
 namespace paddle_mobile {
 
 namespace framework {
-template<typename Dtype> class OperatorBase;
+template <typename Dtype> class OperatorBase;
 class OpDesc;
 class BlockDesc;
 class InferShapeContext;
-}
+} // namespace framework
 
 using VariableNameMap = std::map<std::string, std::vector<std::string>>;
 
-template<typename Dtype>
+template <typename Dtype>
 using OpCreator = std::function<framework::OperatorBase<Dtype> *(
     const std::string & /*type*/, const VariableNameMap & /*inputs*/,
     const VariableNameMap & /*outputs*/,
     const framework::AttributeMap & /*attrs*/)>;
 
 using GradOpMakerFN =
-std::function<std::vector<std::unique_ptr<framework::OpDesc>>(
+    std::function<std::vector<std::unique_ptr<framework::OpDesc>>(
         const framework::OpDesc &,
         const std::unordered_set<std::string> & /*no_grad_set*/,
         std::unordered_map<std::string, std::string> * /*grad_to_var*/,
         const std::vector<framework::BlockDesc *> &grad_block)>;
 
-using InferVarTypeFN =
-std::function<void(const framework::OpDesc & /*op_desc*/,
+using InferVarTypeFN = std::function<void(const framework::OpDesc & /*op_desc*/,
                                           framework::BlockDesc * /*block*/)>;
 
 using InferShapeFN = std::function<void(framework::InferShapeContext *)>;
-};
+}; // namespace paddle_mobile

src/common/types.h

@@ -24,7 +24,7 @@ enum class Precision : int { FP32 = 0 };
 //! device type
 enum DeviceTypeEnum { kINVALID = -1, kCPU = 0, kFPGA = 1, kGPU_MALI = 2 };
 
-template<DeviceTypeEnum T> struct DeviceType {};
+template <DeviceTypeEnum T> struct DeviceType {};
 
 typedef DeviceType<kCPU> CPU;
 typedef DeviceType<kFPGA> FPGA;
@@ -60,4 +60,4 @@ enum PMStatus {
     PMUnImplError = 0x07,    /*!< Unimplement error. */
     PMWrongDevice = 0x08     /*!< un-correct device. */
 };
-}
+} // namespace paddle_mobile

src/common/variant.h

@@ -21,9 +21,9 @@ SOFTWARE.
 #pragma once
 
 namespace paddle_mobile {
-template<int ID, typename Type> struct IDToType { typedef Type type_t; };
+template <int ID, typename Type> struct IDToType { typedef Type type_t; };
 
-template<typename F, typename... Ts> struct VariantHelper {
+template <typename F, typename... Ts> struct VariantHelper {
     static const size_t size = sizeof(F) > VariantHelper<Ts...>::size
                                    ? sizeof(F)
                                    : VariantHelper<Ts...>::size;
@@ -37,7 +37,7 @@ template<typename F, typename... Ts> struct VariantHelper {
     }
 };
 
-template<typename F> struct VariantHelper<F> {
+template <typename F> struct VariantHelper<F> {
     static const size_t size = sizeof(F);
     inline static void Destroy(size_t id, void *data) {
         if (id == typeid(F).hash_code()) {
@@ -48,8 +48,8 @@ template<typename F> struct VariantHelper<F> {
     }
 };
 
-template<size_t size> class RawData {
-public:
+template <size_t size> class RawData {
+  public:
     char data[size];
     RawData() {}
     RawData(const RawData &raw_data) { strcpy(data, raw_data.data); }
@@ -58,7 +58,7 @@ public:
     //      }
 };
 
-template<typename... Ts> struct Variant {
+template <typename... Ts> struct Variant {
     Variant(const Variant &variant) {
         //        std::cout << " 赋值构造函数 " << std::endl;
         type_id = variant.type_id;
@@ -70,13 +70,13 @@ template<typename... Ts> struct Variant {
         //        helper::Destroy(type_id, &data);
     }
 
-  template<typename T, typename... Args> void Set(Args &&... args) {
+    template <typename T, typename... Args> void Set(Args &&... args) {
         helper::Destroy(type_id, &data);
-    new(&data) T(std::forward<Args>(args)...);
+        new (&data) T(std::forward<Args>(args)...);
         type_id = typeid(T).hash_code();
     }
 
-  template<typename T> T &Get() const {
+    template <typename T> T &Get() const {
         if (type_id == typeid(T).hash_code()) {
             return *const_cast<T *>(reinterpret_cast<const T *>(&data));
         } else {
@@ -87,13 +87,13 @@ template<typename... Ts> struct Variant {
 
     size_t TypeId() const { return type_id; }
 
-private:
+  private:
     static inline size_t invalid_type() { return typeid(void).hash_code(); }
     typedef VariantHelper<Ts...> helper;
     size_t type_id;
     RawData<helper::size> data;
 };
 
-template<typename T> struct Vistor { typedef T type_t; };
+template <typename T> struct Vistor { typedef T type_t; };
 
 } // namespace paddle_mobile

src/framework/attribute.h

@@ -27,9 +27,8 @@ namespace framework {
 class BlockDesc;
 
 class Attribute {
-public:
-  static Attribute
-  GetAttrValue(const proto::OpDesc::Attr &attr_desc) {
+  public:
+    static Attribute GetAttrValue(const proto::OpDesc::Attr &attr_desc) {
         //    std::cout << "begin get attr value" << std::endl;
         Attribute attr;
         switch (attr_desc.type()) {
@@ -94,36 +93,35 @@ public:
     }
 
     Attribute() {}
-  template<typename T, typename... Args>
-  Attribute &Set(Args &&... args) {
+    template <typename T, typename... Args> Attribute &Set(Args &&... args) {
         variant_.Set<T>(args...);
         return *this;
     }
 
-  template<typename T> T &Get() const { return variant_.Get<T>(); }
+    template <typename T> T &Get() const { return variant_.Get<T>(); }
 
-private:
-  Variant<int, float, std::string, std::vector<int>,
-          std::vector<float>, std::vector<std::string>, bool,
-          std::vector<bool>, BlockDesc *, int64_t>
+  private:
+    Variant<int, float, std::string, std::vector<int>, std::vector<float>,
+            std::vector<std::string>, bool, std::vector<bool>, BlockDesc *,
+            int64_t>
         variant_;
 };
 
 using AttributeMap = std::unordered_map<std::string, Attribute>;
 
 class AttrReader {
-public:
+  public:
     explicit AttrReader(const AttributeMap &attrs) : attrs_(attrs) {}
 
-  template<typename T> inline T Get(const std::string &name) const {
+    template <typename T> inline T Get(const std::string &name) const {
         //          PADDLE_ENFORCE(attrs_.count(name) != 0, "%s should
         //          be in
         //          AttributeMap",
         //                         name);
-    return ((Attribute) attrs_.at(name)).Get<T>();
+        return ((Attribute)attrs_.at(name)).Get<T>();
     }
 
-private:
+  private:
     const AttributeMap &attrs_;
 };
 

src/framework/block_desc.h

@@ -27,29 +27,26 @@ namespace paddle_mobile {
 namespace framework {
 
 class BlockDesc : PaddleMobileObject {
-public:
+  public:
     BlockDesc(const proto::BlockDesc &desc);
 
     const int &ID() const { return desc_.idx(); }
 
     const int &Parent() const { return desc_.parent_idx(); }
 
-  bool operator==(
-      const paddle_mobile::framework::BlockDesc &in_block) const {
+    bool operator==(const paddle_mobile::framework::BlockDesc &in_block) const {
         return this->ID() == in_block.ID() &&
                this->Parent() == in_block.Parent();
     }
 
-  bool operator<(
-      const paddle_mobile::framework::BlockDesc &in_block) const {
-    return this->ID() < in_block.ID() &&
-        this->Parent() < in_block.Parent();
+    bool operator<(const paddle_mobile::framework::BlockDesc &in_block) const {
+        return this->ID() < in_block.ID() && this->Parent() < in_block.Parent();
     }
 
     std::vector<std::shared_ptr<VarDesc>> Vars() const;
     std::vector<std::shared_ptr<OpDesc>> Ops() const;
 
-private:
+  private:
     proto::BlockDesc desc_;
     std::vector<std::shared_ptr<OpDesc>> ops_;
     std::unordered_map<std::string, std::shared_ptr<VarDesc>> vars_;
@@ -60,7 +57,7 @@ private:
 
 namespace std {
 
-template<> struct hash<paddle_mobile::framework::BlockDesc> {
+template <> struct hash<paddle_mobile::framework::BlockDesc> {
     typedef paddle_mobile::framework::BlockDesc argument_type;
     typedef std::size_t result_type;
     result_type operator()(argument_type const &s) const noexcept {

src/framework/data_layout.h

@@ -46,16 +46,19 @@ inline DataLayout StringToDataLayout(const std::string &str) {
 
 inline std::string DataLayoutToString(const DataLayout &data_layout) {
     switch (data_layout) {
-  case DataLayout::kNHWC:return "NHWC";
-  case DataLayout::kNCHW:return "NCHW";
-  case DataLayout::kAnyLayout:return "ANY_LAYOUT";
-  default:break;
+    case DataLayout::kNHWC:
+        return "NHWC";
+    case DataLayout::kNCHW:
+        return "NCHW";
+    case DataLayout::kAnyLayout:
+        return "ANY_LAYOUT";
+    default:
+        break;
         //      std::cout << "unknown DataLayou %d", data_layout;
     }
 }
 
-inline std::ostream &operator<<(std::ostream &out,
-                                const DataLayout &l) {
+inline std::ostream &operator<<(std::ostream &out, const DataLayout &l) {
     out << DataLayoutToString(l);
     return out;
 }

src/framework/data_transform.cpp

@@ -68,8 +68,8 @@ void DataTransform(const OpKernelType &expected_kernel_type,
     output_tensor->ShareDataWith(in);
 }
 
-void CopyVariableWithTensor(const Variable &in_var,
-                            const Tensor &tensor, Variable &out_var) {
+void CopyVariableWithTensor(const Variable &in_var, const Tensor &tensor,
+                            Variable &out_var) {
     //  if (in_var.IsType<LoDTensor>()) {
     //    auto& in_lod_tensor = in_var.Get<LoDTensor>();
     //    auto* tran_lod_tensor = out_var.GetMutable<LoDTensor>();

src/framework/data_transform.h

@@ -28,14 +28,14 @@ SOFTWARE.
 #include "variable.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        void DataTransform(const OpKernelType &expected_kernel_type,
+void DataTransform(const OpKernelType &expected_kernel_type,
                    const OpKernelType &kernel_type_for_var,
                    const Tensor &input_tensor, Tensor *out);
 
-        void CopyVariableWithTensor(const Variable &in_var,
-                                    const Tensor &tensor, Variable &out_var);
+void CopyVariableWithTensor(const Variable &in_var, const Tensor &tensor,
+                            Variable &out_var);
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/data_type.h

@@ -21,23 +21,23 @@ SOFTWARE.
 #include "framework.pb.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        //    inline proto::VarType::Type ToDataType(std::type_index type) {
-        //        using namespace paddle_mobile::framework::proto;
-        //        if (typeid(float).hash_code() == type.hash_code()) {
-        //            return proto::VarType::FP32;
-        //        } else if (typeid(double).hash_code() == type.hash_code()) {
-        //            return proto::VarType::FP64;
-        //        } else if (typeid(int).hash_code() == type.hash_code()) {
-        //            return proto::VarType::INT32;
-        //        } else if (typeid(int64_t).hash_code() == type.hash_code()) {
-        //            return proto::VarType::INT64;
-        //        } else if (typeid(bool).hash_code() == type.hash_code()) {
-        //            return proto::VarType::BOOL;
-        //        } else {
-        ////            PADDLE_THROW("Not supported");
-        //        }
-        //    }
-    }
+//    inline proto::VarType::Type ToDataType(std::type_index type) {
+//        using namespace paddle_mobile::framework::proto;
+//        if (typeid(float).hash_code() == type.hash_code()) {
+//            return proto::VarType::FP32;
+//        } else if (typeid(double).hash_code() == type.hash_code()) {
+//            return proto::VarType::FP64;
+//        } else if (typeid(int).hash_code() == type.hash_code()) {
+//            return proto::VarType::INT32;
+//        } else if (typeid(int64_t).hash_code() == type.hash_code()) {
+//            return proto::VarType::INT64;
+//        } else if (typeid(bool).hash_code() == type.hash_code()) {
+//            return proto::VarType::BOOL;
+//        } else {
+////            PADDLE_THROW("Not supported");
+//        }
+//    }
+}
 } // namespace paddle_mobile

src/framework/ddim.cc

@@ -15,17 +15,17 @@ limitations under the License. */
 #include "ddim.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        /// @cond HIDDEN
+/// @cond HIDDEN
 
-        template <int i> Dim<i> make_dim(const int64_t *d) {
+template <int i> Dim<i> make_dim(const int64_t *d) {
     return Dim<i>(*d, make_dim<i - 1>(d + 1));
-        }
+}
 
-        template <> Dim<0> make_dim<0>(const int64_t *d) { return Dim<0>(*d); }
+template <> Dim<0> make_dim<0>(const int64_t *d) { return Dim<0>(*d); }
 
-        void make_ddim(DDim &ddim, const int64_t *dims, int n) {
+void make_ddim(DDim &ddim, const int64_t *dims, int n) {
     switch (n) {
     case 0:
         ddim = make_dim<0>(dims);
@@ -63,33 +63,33 @@ namespace paddle_mobile {
         //      dimensions.";
         break;
     }
-        }
+}
 
-        /// @endcond
+/// @endcond
 
-        DDim make_ddim(std::initializer_list<int64_t> dims) {
+DDim make_ddim(std::initializer_list<int64_t> dims) {
     DDim result(make_dim(0));
     make_ddim(result, dims.begin(), dims.size());
     return result;
-        }
+}
 
-        DDim make_ddim(const std::vector<int64_t> &dims) {
+DDim make_ddim(const std::vector<int64_t> &dims) {
     DDim result(make_dim(0));
     make_ddim(result, &dims[0], dims.size());
     return result;
-        }
+}
 
-        DDim make_ddim(const std::vector<int> &dims) {
+DDim make_ddim(const std::vector<int> &dims) {
     std::vector<int64_t> res(dims.size());
     std::transform(dims.begin(), dims.end(), res.begin(),
                    [](int d) { return static_cast<int64_t>(d); });
     return make_ddim(res);
-        }
+}
 
-        /// @cond HIDDEN
-        // XXX For some reason, putting this in an anonymous namespace causes
-        // errors
-        struct DynamicMutableIndexer : Vistor<int64_t &> {
+/// @cond HIDDEN
+// XXX For some reason, putting this in an anonymous namespace causes
+// errors
+struct DynamicMutableIndexer : Vistor<int64_t &> {
   public:
     explicit DynamicMutableIndexer(int idx) : idx_(idx) {}
 
@@ -99,9 +99,9 @@ namespace paddle_mobile {
 
   private:
     int idx_;
-        };
+};
 
-        struct DynamicConstIndexer : public Vistor<int64_t> {
+struct DynamicConstIndexer : public Vistor<int64_t> {
   public:
     explicit DynamicConstIndexer(int idx) : idx_(idx) {}
 
@@ -111,21 +111,21 @@ namespace paddle_mobile {
 
   private:
     int idx_;
-        };
+};
 
-        /// @endcond
+/// @endcond
 
-        int64_t &DDim::operator[](int idx) {
+int64_t &DDim::operator[](int idx) {
     return DDim::ApplyVistor(DynamicMutableIndexer(idx), *this);
-        }
+}
 
-        int64_t DDim::operator[](int idx) const {
+int64_t DDim::operator[](int idx) const {
     return DDim::ApplyVistor(DynamicConstIndexer(idx), *this);
-        }
+}
 
-        int DDim::size() const { return arity(*this); }
+int DDim::size() const { return arity(*this); }
 
-        bool DDim::operator==(DDim d) const {
+bool DDim::operator==(DDim d) const {
     //  if (var.which() != d.getVar().which()) {
     //    return false;
     //  } else {
@@ -140,11 +140,11 @@ namespace paddle_mobile {
 
     return true;
     //  }
-        }
+}
 
-        bool DDim::operator!=(DDim d) const { return !(*this == d); }
+bool DDim::operator!=(DDim d) const { return !(*this == d); }
 
-        DDim DDim::operator+(DDim d) const {
+DDim DDim::operator+(DDim d) const {
     std::vector<int64_t> v1 = vectorize(*this);
     std::vector<int64_t> v2 = vectorize(d);
 
@@ -157,9 +157,9 @@ namespace paddle_mobile {
     }
 
     return make_ddim(v3);
-        }
+}
 
-        DDim DDim::operator*(DDim d) const {
+DDim DDim::operator*(DDim d) const {
     std::vector<int64_t> v1 = vectorize(*this);
     std::vector<int64_t> v2 = vectorize(d);
 
@@ -172,14 +172,14 @@ namespace paddle_mobile {
     }
 
     return make_ddim(v3);
-        }
+}
 
-        int64_t get(const DDim &ddim, int idx) { return ddim[idx]; }
+int64_t get(const DDim &ddim, int idx) { return ddim[idx]; }
 
-        void set(DDim &ddim, int idx, int value) { ddim[idx] = value; }
+void set(DDim &ddim, int idx, int value) { ddim[idx] = value; }
 
-        /// @cond HIDDEN
-        struct VectorizeVisitor : Vistor<void> {
+/// @cond HIDDEN
+struct VectorizeVisitor : Vistor<void> {
     std::vector<int64_t> &vector;
 
     explicit VectorizeVisitor(std::vector<int64_t> &v) : vector(v) {}
@@ -190,36 +190,36 @@ namespace paddle_mobile {
     }
 
     void operator()(const Dim<0> &t) {}
-        };
-        /// @endcond
+};
+/// @endcond
 
-        std::vector<int64_t> vectorize(const DDim &ddim) {
+std::vector<int64_t> vectorize(const DDim &ddim) {
     std::vector<int64_t> result;
     VectorizeVisitor visitor(result);
     DDim::ApplyVistor(visitor, ddim);
     return result;
-        }
+}
 
-        // NOTE: framework::vectorize converts to type int64_t
-        //       which does not fit cudnn inputs.
-        std::vector<int> vectorize2int(const DDim &ddim) {
+// NOTE: framework::vectorize converts to type int64_t
+//       which does not fit cudnn inputs.
+std::vector<int> vectorize2int(const DDim &ddim) {
     std::vector<int64_t> temp = vectorize(ddim);
     std::vector<int> result(temp.begin(), temp.end());
     return result;
-        }
+}
 
-        struct ProductVisitor : Vistor<int64_t> {
+struct ProductVisitor : Vistor<int64_t> {
     template <int D> int64_t operator()(const Dim<D> &dim) {
         return product(dim);
     }
-        };
+};
 
-        int64_t product(const DDim &ddim) {
+int64_t product(const DDim &ddim) {
     ProductVisitor visitor;
     return DDim::ApplyVistor(visitor, ddim);
-        }
+}
 
-        struct SliceVectorizeVisitor : Vistor<void> {
+struct SliceVectorizeVisitor : Vistor<void> {
     std::vector<int64_t> &vector;
     int begin;
     int end;
@@ -251,9 +251,9 @@ namespace paddle_mobile {
         //    PADDLE_ENFORCE(end == 0, "End index in ddim slice is out
         //    of bound.");
     }
-        };
+};
 
-        DDim slice_ddim(const DDim &ddim, int begin, int end) {
+DDim slice_ddim(const DDim &ddim, int begin, int end) {
     std::vector<int64_t> vec;
     vec.reserve(end - begin);
     SliceVectorizeVisitor visitor(vec, begin, end);
@@ -261,27 +261,27 @@ namespace paddle_mobile {
     DDim::ApplyVistor(visitor, ddim);
     //  visitor(ddim.var.Get<Dim<4>>());
     return make_ddim(vec);
-        }
+}
 
-        /// \cond HIDDEN
+/// \cond HIDDEN
 
-        struct ArityVisitor : Vistor<int> {
+struct ArityVisitor : Vistor<int> {
     template <int D> int operator()(Dim<D>) const { return D; }
-        };
+};
 
-        /// \endcond
+/// \endcond
 
-        int arity(const DDim &d) {
+int arity(const DDim &d) {
     ArityVisitor arityVisitor = ArityVisitor();
     return DDim::ApplyVistor(arityVisitor, d);
     //  return arityVisitor(d.var.Get<Dim<4>>());
     //  return boost::apply_visitor(ArityVisitor(), d); }
-        }
-        /// \cond HIDDEN
+}
+/// \cond HIDDEN
 
-        /// \endcond
+/// \endcond
 
-        struct OSVistor : Vistor<std::ostream &> {
+struct OSVistor : Vistor<std::ostream &> {
     OSVistor(std::ostream &os) : os_(os) {}
 
     template <int D> std::ostream &operator()(Dim<D> dim) const {
@@ -290,45 +290,43 @@ namespace paddle_mobile {
 
   private:
     std::ostream &os_;
-        };
+};
 
-        std::ostream &operator<<(std::ostream &os, const DDim &ddim) {
+std::ostream &operator<<(std::ostream &os, const DDim &ddim) {
     auto vistor = OSVistor(os);
     DDim::ApplyVistor(vistor, ddim);
     return os;
-        }
+}
 
-        DDim::DDim(std::initializer_list<int64_t> init_list) {
+DDim::DDim(std::initializer_list<int64_t> init_list) {
     *this = make_ddim(init_list);
-        }
+}
 
-        DDim flatten_to_2d(const DDim &src, int num_col_dims) {
+DDim flatten_to_2d(const DDim &src, int num_col_dims) {
     int rank = src.size();
     return make_ddim({product(slice_ddim(src, 0, num_col_dims)),
                       product(slice_ddim(src, num_col_dims, rank))});
-        }
+}
 
-        DDim flatten_to_1d(const DDim &src) {
-            return make_ddim({product(src)});
-        }
+DDim flatten_to_1d(const DDim &src) { return make_ddim({product(src)}); }
 
-        DDim stride(const DDim &ddim) {
+DDim stride(const DDim &ddim) {
     std::vector<int64_t> strides(ddim.size());
     strides[ddim.size() - 1] = 1;
     for (int i = ddim.size() - 2; i >= 0; --i) {
         strides[i] = strides[i + 1] * ddim[i + 1];
     }
     return framework::make_ddim(strides);
-        }
+}
 
-        DDim stride_numel(const framework::DDim &ddim) {
+DDim stride_numel(const framework::DDim &ddim) {
     std::vector<int64_t> strides(ddim.size());
     strides[ddim.size() - 1] = ddim[ddim.size() - 1];
     for (int i = ddim.size() - 2; i >= 0; --i) {
         strides[i] = strides[i + 1] * ddim[i];
     }
     return framework::make_ddim(strides);
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/ddim.h

@@ -22,22 +22,21 @@ limitations under the License. */
 #include <vector>
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        /**
+/**
  * \brief A dynamically sized dimension.
  *
  * The number of dimensions must be between [1, 9].
  */
-        struct DDim {
-            typedef Variant<Dim<0>, Dim<1>, Dim<2>, Dim<3>, Dim<4>, Dim<5>,
-                            Dim<6>, Dim<7>, Dim<8>, Dim<9>>
+struct DDim {
+    typedef Variant<Dim<0>, Dim<1>, Dim<2>, Dim<3>, Dim<4>, Dim<5>, Dim<6>,
+                    Dim<7>, Dim<8>, Dim<9>>
         DDimVar;
     DDimVar var;
 
     template <typename Vistor>
-            static typename Vistor::type_t ApplyVistor(Vistor vistor,
-                                                       const DDim &d) {
+    static typename Vistor::type_t ApplyVistor(Vistor vistor, const DDim &d) {
         if (d.var.TypeId() == typeid(Dim<0>).hash_code()) {
             return vistor(d.var.Get<Dim<0>>());
         } else if (d.var.TypeId() == typeid(Dim<1>).hash_code()) {
@@ -67,9 +66,7 @@ namespace paddle_mobile {
 
     DDim() { var.Set<Dim<1>>(Dim<1>()); }
 
-            template <int D> explicit DDim(const Dim<D> &in) {
-                var.Set<Dim<D>>(in);
-            }
+    template <int D> explicit DDim(const Dim<D> &in) { var.Set<Dim<D>>(in); }
 
     /*implicit*/ DDim(std::initializer_list<int64_t> init_list);
 
@@ -104,63 +101,63 @@ namespace paddle_mobile {
     DDim operator*(DDim d) const;
 
     int size() const;
-        };
+};
 
-        /**
+/**
  * \brief Make a DDim from std::vector<int64_t>
  *
  * \param dims An vector of ints. Must be sized between [1, 9]
  */
-        DDim make_ddim(const std::vector<int64_t> &dims);
+DDim make_ddim(const std::vector<int64_t> &dims);
 
-        DDim make_ddim(const std::vector<int> &dims);
+DDim make_ddim(const std::vector<int> &dims);
 
-        /**
+/**
  * \brief Make a DDim from an initializer list
  *
  * \param dims An initializer list of ints. Must be sized between [1, 9]
  *
  */
-        DDim make_ddim(std::initializer_list<int64_t> dims);
+DDim make_ddim(std::initializer_list<int64_t> dims);
 
-        int64_t get(const DDim &dim, int idx);
+int64_t get(const DDim &dim, int idx);
 
-        void set(DDim &dim, int idx, int val);
+void set(DDim &dim, int idx, int val);
 
-        std::vector<int64_t> vectorize(const DDim &ddim);
+std::vector<int64_t> vectorize(const DDim &ddim);
 
-        std::vector<int> vectorize2int(const DDim &ddim);
+std::vector<int> vectorize2int(const DDim &ddim);
 
-        int64_t product(const DDim &ddim);
+int64_t product(const DDim &ddim);
 
-        /**
+/**
  * \brief Slice a ddim
  *
  * Slice dim with [begin, end).
  * e.g.  DDim d = make_ddim({1,2,3,4,5});
  *       slice_ddim(d, 1, 3); ====> {2,3}
  */
-        DDim slice_ddim(const DDim &dim, int begin, int end);
+DDim slice_ddim(const DDim &dim, int begin, int end);
 
-        /**
+/**
  * \brief What is the length of this dimension?
  *
  * \param Dynamic dimension to inspect
  */
 
-        int arity(const DDim &ddim);
+int arity(const DDim &ddim);
 
-        std::ostream &operator<<(std::ostream &, const DDim &);
+std::ostream &operator<<(std::ostream &, const DDim &);
 
-        // Reshape a tensor to a matrix. The matrix's first dimension(column
-        // length)
-        // will be the product of tensor's first `num_col_dims` dimensions.
-        DDim flatten_to_2d(const DDim &src, int num_col_dims);
+// Reshape a tensor to a matrix. The matrix's first dimension(column
+// length)
+// will be the product of tensor's first `num_col_dims` dimensions.
+DDim flatten_to_2d(const DDim &src, int num_col_dims);
 
-        DDim flatten_to_1d(const DDim &src);
+DDim flatten_to_1d(const DDim &src);
 
-        DDim stride(const DDim &ddim);
+DDim stride(const DDim &ddim);
 
-        DDim stride_numel(const DDim &ddim);
-    } // namespace framework
+DDim stride_numel(const DDim &ddim);
+} // namespace framework
 } // namespace paddle_mobile

src/framework/dim.h

@@ -21,23 +21,20 @@
 #include "platform/hostdevice.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        // Statically sized, statically indexed dimension
-        template <int i> struct Dim {
+// Statically sized, statically indexed dimension
+template <int i> struct Dim {
     static constexpr int dimensions = i;
 
     template <typename... Args>
-            HOSTDEVICE Dim(int64_t _head, Args... _tail)
-                : head(_head), tail(_tail...) {
-                static_assert(
-                    sizeof...(_tail) == i - 1,
+    HOSTDEVICE Dim(int64_t _head, Args... _tail) : head(_head), tail(_tail...) {
+        static_assert(sizeof...(_tail) == i - 1,
                       "Dim initialized with the wrong number of parameters");
     }
 
     HOSTDEVICE
-            Dim(int64_t _head, const Dim<i - 1> &_tail)
-                : head(_head), tail(_tail) {}
+    Dim(int64_t _head, const Dim<i - 1> &_tail) : head(_head), tail(_tail) {}
 
     HOSTDEVICE
     Dim() : head(0), tail() {}
@@ -70,10 +67,10 @@ namespace paddle_mobile {
 
     int64_t head;
     Dim<i - 1> tail;
-        };
+};
 
-        // Base case specialization
-        template <> struct Dim<0> {
+// Base case specialization
+template <> struct Dim<0> {
     static constexpr int dimensions = 0;
 
     HOSTDEVICE
@@ -103,41 +100,38 @@ namespace paddle_mobile {
     int64_t &operator[](int idx);
     HOSTDEVICE
     int64_t operator[](int idx) const;
-        };
+};
 
-        namespace {
+namespace {
 
-            // Helper for accessing Dim classes
-            template <int i> struct DimGetter {
+// Helper for accessing Dim classes
+template <int i> struct DimGetter {
     // Return a copy if Dim is const
-                template <typename D>
-                HOSTDEVICE static int64_t impl(const D &d) {
+    template <typename D> HOSTDEVICE static int64_t impl(const D &d) {
         return DimGetter<i - 1>::impl(d.tail);
     }
     // Return a reference if Dim is mutable
     template <typename D> HOSTDEVICE static int64_t &impl(D &d) {
         return DimGetter<i - 1>::impl(d.tail);
     }
-            };
+};
 
-            // Eureka! We found the element!
-            template <> struct DimGetter<0> {
+// Eureka! We found the element!
+template <> struct DimGetter<0> {
     // Return a copy if Dim is const
-                template <typename D>
-                HOSTDEVICE static int64_t impl(const D &d) {
+    template <typename D> HOSTDEVICE static int64_t impl(const D &d) {
         return d.head;
     }
     // Return a reference if Dim is mutable
     template <typename D> HOSTDEVICE static int64_t &impl(D &d) {
         return d.head;
     }
-            };
+};
 
-            template <int D> HOSTDEVICE int64_t &indexer(Dim<D> &dim, int idx) {
+template <int D> HOSTDEVICE int64_t &indexer(Dim<D> &dim, int idx) {
 #ifndef __CUDA_ARCH__
     if (idx < 0) {
-                    throw std::invalid_argument(
-                        "Tried to access a negative dimension");
+        throw std::invalid_argument("Tried to access a negative dimension");
     }
 #else
     PADDLE_ASSERT(idx >= 0);
@@ -146,9 +140,9 @@ namespace paddle_mobile {
         return dim.head;
     }
     return indexer(dim.tail, idx - 1);
-            }
+}
 
-            template <> HOSTDEVICE int64_t &indexer<0>(Dim<0> &dim, int idx) {
+template <> HOSTDEVICE int64_t &indexer<0>(Dim<0> &dim, int idx) {
 #ifndef __CUDA_ARCH__
     throw std::invalid_argument("Invalid index");
 #else
@@ -162,14 +156,12 @@ namespace paddle_mobile {
 #endif
     return head;
 #endif
-            }
+}
 
-            template <int D>
-            HOSTDEVICE int64_t indexer(const Dim<D> &dim, int idx) {
+template <int D> HOSTDEVICE int64_t indexer(const Dim<D> &dim, int idx) {
 #ifndef __CUDA_ARCH__
     if (idx < 0) {
-                    throw std::invalid_argument(
-                        "Tried to access a negative dimension");
+        throw std::invalid_argument("Tried to access a negative dimension");
     }
 #else
     PADDLE_ASSERT(idx >= 0);
@@ -178,10 +170,9 @@ namespace paddle_mobile {
         return dim.head;
     }
     return indexer(dim.tail, idx - 1);
-            }
+}
 
-            template <>
-            HOSTDEVICE int64_t indexer<0>(const Dim<0> &dim, int idx) {
+template <> HOSTDEVICE int64_t indexer<0>(const Dim<0> &dim, int idx) {
 #ifndef __CUDA_ARCH__
     throw std::invalid_argument("Invalid index");
 #else
@@ -195,152 +186,146 @@ namespace paddle_mobile {
 #endif
     return head;
 #endif
-            }
+}
 
-        } // namespace
-        // Static access to constant Dim
-        template <int i, int l> HOSTDEVICE int64_t get(const Dim<l> &d) {
+} // namespace
+// Static access to constant Dim
+template <int i, int l> HOSTDEVICE int64_t get(const Dim<l> &d) {
     return DimGetter<i>::impl(d);
-        }
+}
 
-        // Static access to mutable Dim
-        template <int i, int l> HOSTDEVICE int64_t &get(Dim<l> &d) {
+// Static access to mutable Dim
+template <int i, int l> HOSTDEVICE int64_t &get(Dim<l> &d) {
     return DimGetter<i>::impl(d);
-        }
+}
 
-        // Dynamic access to constant Dim
-        template <int l> HOSTDEVICE int64_t Dim<l>::operator[](int i) const {
+// Dynamic access to constant Dim
+template <int l> HOSTDEVICE int64_t Dim<l>::operator[](int i) const {
     //  std::cout << "l: " << l << std::endl;
     return indexer(*this, i);
-        }
+}
 
-        // Dynamic access to mutable Dim
-        template <int l> HOSTDEVICE int64_t &Dim<l>::operator[](int i) {
+// Dynamic access to mutable Dim
+template <int l> HOSTDEVICE int64_t &Dim<l>::operator[](int i) {
     return indexer(*this, i);
-        }
+}
 
-        // Dynamic access to constant Dim
-        inline HOSTDEVICE int64_t Dim<0>::operator[](int i) const {
+// Dynamic access to constant Dim
+inline HOSTDEVICE int64_t Dim<0>::operator[](int i) const {
     return indexer(*this, i);
-        }
+}
 
-        // Dynamic access to mutable Dim
-        inline HOSTDEVICE int64_t &Dim<0>::operator[](int i) {
+// Dynamic access to mutable Dim
+inline HOSTDEVICE int64_t &Dim<0>::operator[](int i) {
     return indexer(*this, i);
-        }
+}
 
-        // Dynamic access to constant Dim
-        // without std::enable_if will try to instantiate this on get<0>(d)
-        template <int l>
-        HOSTDEVICE typename std::enable_if<(l > 0), int64_t>::type
-        get(const Dim<l> &d, int i) {
+// Dynamic access to constant Dim
+// without std::enable_if will try to instantiate this on get<0>(d)
+template <int l>
+HOSTDEVICE typename std::enable_if<(l > 0), int64_t>::type get(const Dim<l> &d,
+                                                               int i) {
     return d[i];
-        }
+}
 
-        // Dynamic access to mutable Dim
-        template <int l>
-        HOSTDEVICE typename std::enable_if<(l > 0), int64_t &>::type
-        get(Dim<l> &d, int i) {
+// Dynamic access to mutable Dim
+template <int l>
+HOSTDEVICE typename std::enable_if<(l > 0), int64_t &>::type get(Dim<l> &d,
+                                                                 int i) {
     return d[i];
-        }
+}
 
-        // Dot product of two dims
-        template <int i>
-        HOSTDEVICE int64_t linearize(const Dim<i> &a, const Dim<i> &b) {
+// Dot product of two dims
+template <int i>
+HOSTDEVICE int64_t linearize(const Dim<i> &a, const Dim<i> &b) {
     return a.head * b.head + linearize(a.tail, b.tail);
-        }
+}
 
-        // Base case dot product of two Dims
-        // Notice it is inline because it is no longer a template
-        template <>
-        HOSTDEVICE inline int64_t linearize(const Dim<0> &a, const Dim<0> &b) {
+// Base case dot product of two Dims
+// Notice it is inline because it is no longer a template
+template <>
+HOSTDEVICE inline int64_t linearize(const Dim<0> &a, const Dim<0> &b) {
     return 0;
-        }
+}
 
-        // Product of a Dim
-        template <int i>
-        HOSTDEVICE int64_t product(const Dim<i> &a, int prod = 1) {
+// Product of a Dim
+template <int i> HOSTDEVICE int64_t product(const Dim<i> &a, int prod = 1) {
     return prod * a.head * product(a.tail);
-        }
+}
 
-        // Base case product of a Dim
-        // Notice it is inline because it is no longer a template
-        template <>
-        HOSTDEVICE inline int64_t product(const Dim<0> &a, int prod) {
+// Base case product of a Dim
+// Notice it is inline because it is no longer a template
+template <> HOSTDEVICE inline int64_t product(const Dim<0> &a, int prod) {
     return prod;
-        }
+}
 
-        // Is 0 <= idx_i < size_i for all i?
-        template <int i>
-        HOSTDEVICE bool contained(const Dim<i> &idx, const Dim<i> &size) {
+// Is 0 <= idx_i < size_i for all i?
+template <int i>
+HOSTDEVICE bool contained(const Dim<i> &idx, const Dim<i> &size) {
     return ((0 <= idx.head) && (idx.head < size.head) &&
             contained(idx.tail, size.tail));
-        }
+}
 
-        // Base case of is 0 <= idx_i < size_i ?
-        // Notice it is inline because it is no longer a template
-        template <>
-        HOSTDEVICE inline bool contained(const Dim<0> &idx,
-                                         const Dim<0> &size) {
+// Base case of is 0 <= idx_i < size_i ?
+// Notice it is inline because it is no longer a template
+template <>
+HOSTDEVICE inline bool contained(const Dim<0> &idx, const Dim<0> &size) {
     return true;
-        }
+}
 
-        /**
+/**
  * \brief Compute exclusive prefix-multiply of a Dim.
  */
-        template <int i>
-        HOSTDEVICE Dim<i> ex_prefix_mul(const Dim<i> &src, int mul = 1) {
+template <int i>
+HOSTDEVICE Dim<i> ex_prefix_mul(const Dim<i> &src, int mul = 1) {
     return Dim<i>(mul, ex_prefix_mul(src.tail, mul * src.head));
-        }
+}
 
-        ///\cond HIDDEN
-        // Base case of ex_prefix_mul
-        // Notice it is inline because it is no longer a template
-        template <>
-        HOSTDEVICE inline Dim<0> ex_prefix_mul(const Dim<0> &src, int mul) {
+///\cond HIDDEN
+// Base case of ex_prefix_mul
+// Notice it is inline because it is no longer a template
+template <> HOSTDEVICE inline Dim<0> ex_prefix_mul(const Dim<0> &src, int mul) {
     return Dim<0>();
-        }
-        ///\endcond
+}
+///\endcond
 
-        /**
+/**
  * Add two dimensions together
  */
-        template <int i>
-        HOSTDEVICE Dim<i> dim_plus(const Dim<i> &a, const Dim<i> &b) {
+template <int i> HOSTDEVICE Dim<i> dim_plus(const Dim<i> &a, const Dim<i> &b) {
     return Dim<i>(a.head + b.head, dim_plus(a.tail, b.tail));
-        }
+}
 
-        // Base case
-        template <>
-        HOSTDEVICE inline Dim<0> dim_plus(const Dim<0> &a, const Dim<0> &b) {
+// Base case
+template <>
+HOSTDEVICE inline Dim<0> dim_plus(const Dim<0> &a, const Dim<0> &b) {
     return Dim<0>();
-        }
+}
 
-        template <int i>
-        HOSTDEVICE Dim<i> operator+(const Dim<i> &lhs, const Dim<i> &rhs) {
+template <int i>
+HOSTDEVICE Dim<i> operator+(const Dim<i> &lhs, const Dim<i> &rhs) {
     return dim_plus(lhs, rhs);
-        }
+}
 
-        /**
+/**
  * Multiply two dimensions together
  */
-        template <int i>
-        HOSTDEVICE Dim<i> dim_mult(const Dim<i> &a, const Dim<i> &b) {
+template <int i> HOSTDEVICE Dim<i> dim_mult(const Dim<i> &a, const Dim<i> &b) {
     return Dim<i>(a.head * b.head, dim_mult(a.tail, b.tail));
-        }
+}
 
-        // Base case
-        template <>
-        HOSTDEVICE inline Dim<0> dim_mult(const Dim<0> &a, const Dim<0> &b) {
+// Base case
+template <>
+HOSTDEVICE inline Dim<0> dim_mult(const Dim<0> &a, const Dim<0> &b) {
     return Dim<0>();
-        }
+}
 
-        template <int i>
-        HOSTDEVICE Dim<i> operator*(const Dim<i> &lhs, const Dim<i> &rhs) {
+template <int i>
+HOSTDEVICE Dim<i> operator*(const Dim<i> &lhs, const Dim<i> &rhs) {
     return dim_mult(lhs, rhs);
-        }
+}
 
-        /**
+/**
  * \brief Normalize strides to ensure any dimension with extent 1
  * has stride 0.
  *
@@ -350,25 +335,23 @@ namespace paddle_mobile {
  *
  */
 
-        template <int i>
-        HOSTDEVICE Dim<i> normalize_strides(const Dim<i> &size,
-                                            const Dim<i> &stride) {
+template <int i>
+HOSTDEVICE Dim<i> normalize_strides(const Dim<i> &size, const Dim<i> &stride) {
     int norm_stride = size.head == 1 ? 0 : stride.head;
-            return Dim<i>(norm_stride,
-                          normalize_strides(size.tail, stride.tail));
-        }
+    return Dim<i>(norm_stride, normalize_strides(size.tail, stride.tail));
+}
 
-        ///\cond HIDDEN
+///\cond HIDDEN
 
-        template <>
-        HOSTDEVICE inline Dim<0> normalize_strides(const Dim<0> &size,
+template <>
+HOSTDEVICE inline Dim<0> normalize_strides(const Dim<0> &size,
                                            const Dim<0> &stride) {
     return Dim<0>();
-        }
+}
 
-        ///\endcond
+///\endcond
 
-        /**
+/**
  * Helper function to create a Dim
  *
  * \param idxes The type of Dim constructed depends on the number of
@@ -376,44 +359,43 @@ namespace paddle_mobile {
  *
  */
 
-        template <typename... Args>
-        HOSTDEVICE Dim<sizeof...(Args)> make_dim(Args... idxes) {
+template <typename... Args>
+HOSTDEVICE Dim<sizeof...(Args)> make_dim(Args... idxes) {
     return Dim<sizeof...(Args)>(idxes...);
-        }
+}
 
-        // Allows us to output a Dim
-        // XXX For some reason, overloading fails to resolve this correctly
-        template <int i>
-        typename std::enable_if<(i > 1), std::ostream &>::type
-        operator<<(std::ostream &os, const Dim<i> &d) {
+// Allows us to output a Dim
+// XXX For some reason, overloading fails to resolve this correctly
+template <int i>
+typename std::enable_if<(i > 1), std::ostream &>::type
+operator<<(std::ostream &os, const Dim<i> &d) {
     os << d.head << ", " << d.tail;
     return os;
-        }
+}
 
-        // Base case that allows us to output a Dim
-        // XXX I wish this could be an overload instead of a template
-        template <int i>
-        typename std::enable_if<(i == 1), std::ostream &>::type
-        operator<<(std::ostream &os, const Dim<i> &d) {
+// Base case that allows us to output a Dim
+// XXX I wish this could be an overload instead of a template
+template <int i>
+typename std::enable_if<(i == 1), std::ostream &>::type
+operator<<(std::ostream &os, const Dim<i> &d) {
     os << d.head;
     return os;
-        }
+}
 
-        inline std::ostream &operator<<(std::ostream &os, const Dim<0> &d) {
+inline std::ostream &operator<<(std::ostream &os, const Dim<0> &d) {
     return os;
-        }
+}
 
-        template <int i> HOST std::string Dim<i>::to_string() const {
+template <int i> HOST std::string Dim<i>::to_string() const {
     std::stringstream stream;
 
     stream << *this;
 
     return stream.str();
-        }
+}
 
-        template <int D>
-        HOSTDEVICE Dim<D> linear_to_dimension(int linear_index,
-                                              Dim<D> extents) {
+template <int D>
+HOSTDEVICE Dim<D> linear_to_dimension(int linear_index, Dim<D> extents) {
     Dim<D> result;
 
     for (int i = 0; i < D - 1; ++i) {
@@ -424,7 +406,7 @@ namespace paddle_mobile {
     result[D - 1] = linear_index;
 
     return result;
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/executor.cpp

@@ -23,10 +23,10 @@ SOFTWARE.
 #include "variable.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype>
-        Executor<Dtype>::Executor(const Program<Dtype> p) : program_(p) {
+template <typename Dtype>
+Executor<Dtype>::Executor(const Program<Dtype> p) : program_(p) {
     if (use_optimize_) {
         to_predict_program_ = program_.optimizeProgram;
     } else {
@@ -40,11 +40,9 @@ namespace paddle_mobile {
         std::vector<std::shared_ptr<OpDesc>> ops = block_desc->Ops();
         for (int j = 0; j < ops.size(); ++j) {
             std::shared_ptr<OpDesc> op = ops[j];
-                    if (op->Type() == "conv2d" &&
-                        op->Input("Input")[0] == "pixel") {
+            if (op->Type() == "conv2d" && op->Input("Input")[0] == "pixel") {
                 Attribute strides_attr = op->GetAttrMap().at("strides");
-                        std::vector<int> stride =
-                            strides_attr.Get<std::vector<int>>();
+                std::vector<int> stride = strides_attr.Get<std::vector<int>>();
                 for (int k = 0; k < stride.size(); ++k) {
                 }
                 std::shared_ptr<operators::ConvOp<Dtype, float>> conv =
@@ -55,10 +53,10 @@ namespace paddle_mobile {
             }
         }
     }
-        }
+}
 
-        template <typename Dtype>
-        std::shared_ptr<Tensor> Executor<Dtype>::predict(Tensor &t) {
+template <typename Dtype>
+std::shared_ptr<Tensor> Executor<Dtype>::predict(Tensor &t) {
     // feed
     auto scope = program_.scope;
     Variable *g_feed_value = scope->Var("pixel");
@@ -77,21 +75,20 @@ namespace paddle_mobile {
 
     predict(t, 0);
     return out_tensor;
-        }
+}
 
-        template <typename Dtype>
-        void Executor<Dtype>::predict(const Tensor &t, int block_id) {
+template <typename Dtype>
+void Executor<Dtype>::predict(const Tensor &t, int block_id) {
     std::shared_ptr<BlockDesc> to_predict_block =
         to_predict_program_->Block(block_id);
-            for (int j = 0; j < ops_of_block_[*to_predict_block.get()].size();
-                 ++j) {
+    for (int j = 0; j < ops_of_block_[*to_predict_block.get()].size(); ++j) {
         auto op = ops_of_block_[*to_predict_block.get()][j];
         //    std::cout << "开始run" << std::endl;
         op->Run();
     }
-        }
+}
 
-        template class Executor<CPU>;
+template class Executor<CPU>;
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/executor.h

@@ -32,9 +32,9 @@ SOFTWARE.
 #include "variable.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype> class Executor {
+template <typename Dtype> class Executor {
   public:
     Executor(const Program<Dtype> p);
     std::shared_ptr<Tensor> predict(Tensor &t);
@@ -47,7 +47,7 @@ namespace paddle_mobile {
              std::vector<std::shared_ptr<OperatorBase<Dtype>>>>
         ops_of_block_;
     bool use_optimize_ = false;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/lod_tensor.cc

@@ -19,9 +19,9 @@ limitations under the License. */
 #include <string.h>
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        std::ostream &operator<<(std::ostream &os, const LoD &lod) {
+std::ostream &operator<<(std::ostream &os, const LoD &lod) {
     os << "{";
     for (auto &v : lod) {
         os << "{";
@@ -39,9 +39,9 @@ namespace paddle_mobile {
     os << "}";
 
     return os;
-        }
+}
 
-        std::ostream &operator<<(std::ostream &os, const LoDTensor &t) {
+std::ostream &operator<<(std::ostream &os, const LoDTensor &t) {
     //  PADDLE_ENFORCE(t.type().hash_code() ==
     //  typeid(float).hash_code());
 
@@ -66,15 +66,15 @@ namespace paddle_mobile {
     }
 
     return os;
-        }
+}
 
-        std::string LoDToString(const LoD &lod) {
+std::string LoDToString(const LoD &lod) {
     std::ostringstream stream;
     stream << lod;
     return stream.str();
-        }
+}
 
-        LoD SliceInLevel(const LoD &in, size_t level, size_t elem_begin,
+LoD SliceInLevel(const LoD &in, size_t level, size_t elem_begin,
                  size_t elem_end) {
     //  PADDLE_ENFORCE_LT(level, in.size());
     //  PADDLE_ENFORCE_LT(elem_end, in[level].size());
@@ -101,24 +101,23 @@ namespace paddle_mobile {
         }
     }
     return res;
-        }
+}
 
-        LoD ToAbsOffset(const LoD &in) {
+LoD ToAbsOffset(const LoD &in) {
     // the lowest level stores relative offsets
     if (in.empty() || in.size() == 1)
         return in;
     LoD result = in;
-            for (auto level = static_cast<int>(in.size() - 2); level >= 0;
-                 level--) {
+    for (auto level = static_cast<int>(in.size() - 2); level >= 0; level--) {
         for (size_t i = 0; i < in[level].size(); ++i) {
             size_t index = in[level][i];
             result[level][i] = result[level + 1][index];
         }
     }
     return result;
-        }
+}
 
-        bool operator==(const LoD &a, const LoD &b) {
+bool operator==(const LoD &a, const LoD &b) {
     if (a.size() != b.size()) {
         return false;
     }
@@ -136,9 +135,9 @@ namespace paddle_mobile {
         }
     }
     return true;
-        }
+}
 
-        bool CheckLoD(const LoD &in, int tensor_height) {
+bool CheckLoD(const LoD &in, int tensor_height) {
     if (in.empty())
         return true;
     for (const auto &level : in) {
@@ -180,9 +179,9 @@ namespace paddle_mobile {
             return false;
     }
     return true;
-        }
+}
 
-        bool CheckAbsLoD(const LoD &in, int tensor_height) {
+bool CheckAbsLoD(const LoD &in, int tensor_height) {
     if (in.empty())
         return true;
     for (const auto &level : in) {
@@ -215,24 +214,20 @@ namespace paddle_mobile {
         }
     }
     return true;
-        }
+}
 
-        using LoDAndOffset = std::pair<LoD, std::pair<size_t, size_t>>;
+using LoDAndOffset = std::pair<LoD, std::pair<size_t, size_t>>;
 
-        LoDAndOffset GetSubLoDAndAbsoluteOffset(const LoD &lod,
-                                                size_t start_idx,
-                                                size_t end_idx,
-                                                size_t start_level) {
+LoDAndOffset GetSubLoDAndAbsoluteOffset(const LoD &lod, size_t start_idx,
+                                        size_t end_idx, size_t start_level) {
     LoD sub_lod;
 
-            for (size_t level_idx = start_level; level_idx < lod.size();
-                 ++level_idx) {
+    for (size_t level_idx = start_level; level_idx < lod.size(); ++level_idx) {
         //    PADDLE_ENFORCE_LE(start_idx, end_idx);
         //    PADDLE_ENFORCE_LT(end_idx, lod[level_idx].size());
         std::vector<size_t> level_lens;
         for (size_t i = start_idx; i < end_idx; ++i) {
-                    level_lens.push_back(lod[level_idx][i + 1] -
-                                         lod[level_idx][i]);
+            level_lens.push_back(lod[level_idx][i + 1] - lod[level_idx][i]);
         }
         sub_lod.emplace_back(level_lens);
         start_idx = lod[level_idx][start_idx];
@@ -240,9 +235,9 @@ namespace paddle_mobile {
     }
 
     return LoDAndOffset{sub_lod, {start_idx, end_idx}};
-        }
+}
 
-        void AppendLoD(LoD *lod, const LoD &lod_length) {
+void AppendLoD(LoD *lod, const LoD &lod_length) {
     //  PADDLE_ENFORCE(
     //      lod->empty() || lod->size() == lod_length.size(),
     //      "The lod_length should has the same size with the appended
@@ -259,13 +254,12 @@ namespace paddle_mobile {
             level.push_back(level.back() + len);
         }
     }
-        }
+}
 
-        void SerializeToStream(std::ostream &os, const LoDTensor &tensor) {
+void SerializeToStream(std::ostream &os, const LoDTensor &tensor) {
     { // the 1st field, uint32_t version for LoDTensor
         constexpr uint32_t version = 0;
-                os.write(reinterpret_cast<const char *>(&version),
-                         sizeof(version));
+        os.write(reinterpret_cast<const char *>(&version), sizeof(version));
     }
     {
         // the 2st field, LoD information
@@ -278,19 +272,17 @@ namespace paddle_mobile {
         os.write(reinterpret_cast<const char *>(&size), sizeof(size));
 
         for (auto &each : lod) {
-                    size = each.size() *
-                           sizeof(framework::LoD::value_type::value_type);
-                    os.write(reinterpret_cast<const char *>(&size),
-                             sizeof(size));
+            size = each.size() * sizeof(framework::LoD::value_type::value_type);
+            os.write(reinterpret_cast<const char *>(&size), sizeof(size));
             os.write(reinterpret_cast<const char *>(each.data()),
                      static_cast<std::streamsize>(size));
         }
     }
     // the 3st field, Tensor
     TensorToStream(os, static_cast<Tensor>(tensor));
-        }
+}
 
-        void DeserializeFromStream(std::istream &is, LoDTensor *tensor) {
+void DeserializeFromStream(std::istream &is, LoDTensor *tensor) {
     {
         // the 1st field, unit32_t version for LoDTensor
         uint32_t version;
@@ -301,8 +293,7 @@ namespace paddle_mobile {
     {
         // the 2st field, LoD information
         uint64_t lod_level;
-                is.read(reinterpret_cast<char *>(&lod_level),
-                        sizeof(lod_level));
+        is.read(reinterpret_cast<char *>(&lod_level), sizeof(lod_level));
         auto &lod = *tensor->mutable_lod();
         lod.resize(lod_level);
         for (uint64_t i = 0; i < lod_level; ++i) {
@@ -316,7 +307,7 @@ namespace paddle_mobile {
     }
     // the 3st filed, Tensor
     TensorFromStream(is, static_cast<Tensor *>(tensor));
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/lod_tensor.h

@@ -23,9 +23,9 @@ limitations under the License. */
 
 namespace paddle_mobile {
 
-    namespace framework {
+namespace framework {
 
-        /*
+/*
  * LoD is short for Level of Details.
  *
  * - in a level, each element indicates relative offset of the lower
@@ -42,25 +42,25 @@ namespace paddle_mobile {
  *    0 2 4 7
  *    0 2 5 7 10 12 15 20
  */
-        using LoD = std::vector<std::vector<size_t>>;
+using LoD = std::vector<std::vector<size_t>>;
 
-        std::ostream &operator<<(std::ostream &os, const LoD &lod);
+std::ostream &operator<<(std::ostream &os, const LoD &lod);
 
-        std::ostream &operator<<(std::ostream &os, const LoDTensor &t);
+std::ostream &operator<<(std::ostream &os, const LoDTensor &t);
 
-        std::string LoDToString(const LoD &lod);
+std::string LoDToString(const LoD &lod);
 
-        LoD SliceInLevel(const LoD &in, size_t level, size_t elem_begin,
+LoD SliceInLevel(const LoD &in, size_t level, size_t elem_begin,
                  size_t elem_end);
 
-        /*
+/*
  * Transform an LoD from relative offsets to absolute offsets.
  */
-        LoD ToAbsOffset(const LoD &in);
+LoD ToAbsOffset(const LoD &in);
 
-        bool operator==(const LoD &a, const LoD &b);
+bool operator==(const LoD &a, const LoD &b);
 
-        /*
+/*
  * Check whether this lod's format is valid.
  *
  * ATTENTION:
@@ -78,9 +78,9 @@ namespace paddle_mobile {
  * tensor_height>0.
  */
 
-        bool CheckLoD(const LoD &in, int tensor_height = -1);
+bool CheckLoD(const LoD &in, int tensor_height = -1);
 
-        /*
+/*
  * Check whether this absolute lod's format is valid.
  *
  * ATTENTION:
@@ -95,13 +95,13 @@ namespace paddle_mobile {
  *     same(the height of underlying tensor) or `tensor_height` if
  *     tensor_height>0.
  */
-        bool CheckAbsLoD(const LoD &in, int tensor_height = -1);
+bool CheckAbsLoD(const LoD &in, int tensor_height = -1);
 
-        /*
+/*
  * LoDTensor (Level of details Tensor)
  * see https://en.wikipedia.org/wiki/Level_of_details for reference.
  */
-        class LoDTensor : public Tensor {
+class LoDTensor : public Tensor {
   public:
     LoDTensor() : Tensor() {}
 
@@ -116,12 +116,10 @@ namespace paddle_mobile {
     /*
      * Get the start offset and end offset of an  element from LoD.
      */
-            std::pair<size_t, size_t> lod_element(size_t level,
-                                                  size_t elem) const {
+    std::pair<size_t, size_t> lod_element(size_t level, size_t elem) const {
         //    PADDLE_ENFORCE_LT(level, NumLevels());
         //    PADDLE_ENFORCE_LT(elem, NumElements(level));
-                return std::make_pair((lod_)[level][elem],
-                                      (lod_)[level][elem + 1]);
+        return std::make_pair((lod_)[level][elem], (lod_)[level][elem + 1]);
     }
 
     /*
@@ -143,9 +141,9 @@ namespace paddle_mobile {
 
   private:
     LoD lod_;
-        };
+};
 
-        /*
+/*
  * Expand the `source` to fit the LoD of `lod`. For example, a `source`
  * LoDTensor is
  *  - LoD: [0, 2]
@@ -155,9 +153,8 @@ namespace paddle_mobile {
  * returns a new LoDTensor
  *  - [a0 a0 a0 a1 a1]
  */
-        template <typename T>
-        LoDTensor LodExpand(const LoDTensor &source, const LoD &lod,
-                            size_t level) {
+template <typename T>
+LoDTensor LodExpand(const LoDTensor &source, const LoD &lod, size_t level) {
     LoD abs_lod = ToAbsOffset(lod);
     const auto &lod_level = lod[level];
     size_t num_instances = source.dims()[0];
@@ -172,41 +169,40 @@ namespace paddle_mobile {
 
     //  PADDLE_ENFORCE_EQ(num_instances, lod_level.size() - 1);
     for (size_t ins = 0; ins < num_instances; ins++) {
-                for (size_t elem = lod_level[ins]; elem < lod_level[ins + 1];
-                     elem++) {
+        for (size_t elem = lod_level[ins]; elem < lod_level[ins + 1]; elem++) {
             auto slice = tensor.Slice(elem, elem + 1);
             TensorCopy(source.Slice(ins, ins + 1), &slice);
         }
     }
     return tensor;
-        }
-
-        // Get the absolute offset of a lod[start_level][start_idx:end_idx] and
-        // relative length of details for every levels(i.e., [start_level: ]).
-        //
-        // For example,
-        //   lod = [[0, 3, 4, 8], [0, 9, 10, 11, 13, 17, 19, 22, 24]]
-        //   start_level = 0
-        //   start_idx = 1
-        //   end_idx = 3
-        //
-        // Returns:
-        //  LoD = [[1, 4], [2, 4, 2, 3, 2]]
-        //  pair<size_t, size_t> = {11, 24}
-        std::pair<LoD, std::pair<size_t, size_t>>
-        GetSubLoDAndAbsoluteOffset(const LoD &lod, size_t start_idx,
-                                   size_t end_idx, size_t start_level);
-
-        void AppendLoD(LoD *lod, const LoD &lod_length);
-
-        /*
+}
+
+// Get the absolute offset of a lod[start_level][start_idx:end_idx] and
+// relative length of details for every levels(i.e., [start_level: ]).
+//
+// For example,
+//   lod = [[0, 3, 4, 8], [0, 9, 10, 11, 13, 17, 19, 22, 24]]
+//   start_level = 0
+//   start_idx = 1
+//   end_idx = 3
+//
+// Returns:
+//  LoD = [[1, 4], [2, 4, 2, 3, 2]]
+//  pair<size_t, size_t> = {11, 24}
+std::pair<LoD, std::pair<size_t, size_t>>
+GetSubLoDAndAbsoluteOffset(const LoD &lod, size_t start_idx, size_t end_idx,
+                           size_t start_level);
+
+void AppendLoD(LoD *lod, const LoD &lod_length);
+
+/*
  * Serialize/Desiralize LoDTensor to std::ostream
  * You can pass ofstream or ostringstream to serilize to file
  * or to a in memory string. GPU tensor will be copied to CPU.
  */
-        void SerializeToStream(std::ostream &os, const LoDTensor &tensor);
+void SerializeToStream(std::ostream &os, const LoDTensor &tensor);
 
-        void DeserializeFromStream(std::istream &is, LoDTensor *tensor);
+void DeserializeFromStream(std::istream &is, LoDTensor *tensor);
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/op_desc.cpp

@@ -5,9 +5,9 @@
 #include "op_desc.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        OpDesc::OpDesc(const proto::OpDesc &desc) : desc_(desc) {
+OpDesc::OpDesc(const proto::OpDesc &desc) : desc_(desc) {
     for (int i = 0; i < desc_.inputs_size(); ++i) {
         const proto::OpDesc::Var &var = desc_.inputs(i);
         std::vector<std::string> &args = inputs_[var.parameter()];
@@ -36,27 +36,24 @@ namespace paddle_mobile {
             //      }
         }
     }
-        }
+}
 
-        const std::vector<std::string> &
-        OpDesc::Input(const std::string &name) const {
+const std::vector<std::string> &OpDesc::Input(const std::string &name) const {
     return inputs_.find(name)->second;
-        }
+}
 
-        const std::vector<std::string> &
-        OpDesc::Output(const std::string &name) const {
+const std::vector<std::string> &OpDesc::Output(const std::string &name) const {
     return outputs_.find(name)->second;
-        }
+}
 
-        Attribute OpDesc::GetAttr(const std::string &name) const {
+Attribute OpDesc::GetAttr(const std::string &name) const {
     auto it = attrs_.find(name);
     return it->second;
-        }
+}
 
-        const std::unordered_map<std::string, Attribute> &
-        OpDesc::GetAttrMap() const {
+const std::unordered_map<std::string, Attribute> &OpDesc::GetAttrMap() const {
     return attrs_;
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/op_desc.h

@@ -23,15 +23,13 @@ SOFTWARE.
 #include "paddle_mobile_object.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        class OpDesc : PaddleMobileObject {
+class OpDesc : PaddleMobileObject {
   public:
     OpDesc(const proto::OpDesc &desc);
-            const std::vector<std::string> &
-            Input(const std::string &name) const;
-            const std::vector<std::string> &
-            Output(const std::string &name) const;
+    const std::vector<std::string> &Input(const std::string &name) const;
+    const std::vector<std::string> &Output(const std::string &name) const;
     Attribute GetAttr(const std::string &name) const;
 
     const VariableNameMap &GetInputs() { return inputs_; }
@@ -47,7 +45,7 @@ namespace paddle_mobile {
     VariableNameMap inputs_;
     VariableNameMap outputs_;
     AttributeMap attrs_;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/op_info.h

@@ -22,9 +22,9 @@ SOFTWARE.
 #include "framework.pb.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype> struct OpInfo {
+template <typename Dtype> struct OpInfo {
     OpCreator<Dtype> creator_;
     const OpCreator<Dtype> &Creator() const {
         //    PADDLE_ENFORCE_NOT_NULL(creator_,
@@ -32,14 +32,13 @@ namespace paddle_mobile {
         //                            registered");
         return creator_;
     }
-        };
+};
 
-        template <typename Dtype> class OpInfoMap;
+template <typename Dtype> class OpInfoMap;
 
-        template <typename Dtype>
-        static OpInfoMap<Dtype> *g_op_info_map = nullptr;
+template <typename Dtype> static OpInfoMap<Dtype> *g_op_info_map = nullptr;
 
-        template <typename Dtype> class OpInfoMap {
+template <typename Dtype> class OpInfoMap {
   public:
     static OpInfoMap &Instance() {
         if (g_op_info_map<Dtype> == nullptr) {
@@ -89,7 +88,7 @@ namespace paddle_mobile {
     std::unordered_map<std::string, OpInfo<Dtype>> map_;
 
     //  DISABLE_COPY_AND_ASSIGN(OpInfoMap);
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/op_kernel_type.h

@@ -22,12 +22,11 @@ SOFTWARE.
 #include "framework.pb.h"
 
 namespace paddle_mobile {
-    namespace framework {
-        struct OpKernelType {
+namespace framework {
+struct OpKernelType {
     struct Hash {
         size_t operator()(const OpKernelType &key) const {
-                    int data_type = static_cast<int>(key.data_type_)
-                                    << LEFT_SHIFT;
+            int data_type = static_cast<int>(key.data_type_) << LEFT_SHIFT;
             int data_layout = static_cast<int>(key.data_layout_)
                               << (LEFT_SHIFT * 2);
 
@@ -47,26 +46,20 @@ namespace paddle_mobile {
         : data_type_(data_type), data_layout_(data_layout) {}
 
     bool operator==(const OpKernelType &o) const {
-                return data_type_ == o.data_type_ &&
-                       data_layout_ == o.data_layout_;
+        return data_type_ == o.data_type_ && data_layout_ == o.data_layout_;
     }
 
-            bool operator!=(const OpKernelType &o) const {
-                return !(*this == o);
-            }
-        };
+    bool operator!=(const OpKernelType &o) const { return !(*this == o); }
+};
 
-        inline bool NeedTransformLayout(const DataLayout &l,
-                                        const DataLayout &r) {
-            return l != DataLayout::kAnyLayout && r != DataLayout::kAnyLayout &&
-                   l != r;
-        }
+inline bool NeedTransformLayout(const DataLayout &l, const DataLayout &r) {
+    return l != DataLayout::kAnyLayout && r != DataLayout::kAnyLayout && l != r;
+}
 
-        inline bool TransFromNeeded(const OpKernelType &l,
-                                    const OpKernelType &r) {
+inline bool TransFromNeeded(const OpKernelType &l, const OpKernelType &r) {
     return (l.data_type_ != r.data_type_) ||
            NeedTransformLayout(l.data_layout_, r.data_layout_);
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/op_proto_maker.h

@@ -19,8 +19,8 @@ SOFTWARE.
 #pragma once
 
 namespace paddle_mobile {
-    namespace framework {
-        // this class not only make proto but also init attribute checkers.
-        class OpProtoAndCheckerMaker {};
-    } // namespace framework
+namespace framework {
+// this class not only make proto but also init attribute checkers.
+class OpProtoAndCheckerMaker {};
+} // namespace framework
 } // namespace paddle_mobile

src/framework/operator.cpp

@@ -20,10 +20,10 @@ SOFTWARE.
 #include "op_info.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype>
-        OperatorBase<Dtype>::OperatorBase(const std::string &type,
+template <typename Dtype>
+OperatorBase<Dtype>::OperatorBase(const std::string &type,
                                   const VariableNameMap &inputs,
                                   const VariableNameMap &outputs,
                                   const AttributeMap &attrs,
@@ -31,12 +31,12 @@ namespace paddle_mobile {
     : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs),
       scope_(scope) {
     CheckAllInputOutputSet();
-        }
-        template <typename Dtype>
-        void OperatorBase<Dtype>::CheckAllInputOutputSet() const {}
+}
+template <typename Dtype>
+void OperatorBase<Dtype>::CheckAllInputOutputSet() const {}
 
-        template class OperatorBase<CPU>;
-        template class OperatorWithKernel<CPU>;
+template class OperatorBase<CPU>;
+template class OperatorWithKernel<CPU>;
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/operator.h

@@ -33,8 +33,8 @@ SOFTWARE.
 #include "variable.h"
 
 namespace paddle_mobile {
-    namespace framework {
-        static std::unordered_map<std::string, std::vector<std::string>>
+namespace framework {
+static std::unordered_map<std::string, std::vector<std::string>>
     op_input_output_key = {
         {"conv2d", {"Input", "Output"}},   {"relu", {"X", "Out"}},
         {"softmax", {"X", "Out"}},         {"mul", {"X", "Out"}},
@@ -42,13 +42,12 @@ namespace paddle_mobile {
         {"batch_norm", {"X", "Y"}},        {"lrn", {"X", "Out"}},
         {"concat", {"X", "Out"}},
 
-        };
+};
 
-        template <typename Dtype> class OperatorBase : PaddleMobileObject {
+template <typename Dtype> class OperatorBase : PaddleMobileObject {
   public:
     OperatorBase(const std::string &type, const VariableNameMap &inputs,
-                         const VariableNameMap &outputs,
-                         const AttributeMap &attrs,
+                 const VariableNameMap &outputs, const AttributeMap &attrs,
                  std::shared_ptr<Scope> scope);
     virtual ~OperatorBase() {}
     virtual void Run() const = 0;
@@ -73,28 +72,25 @@ namespace paddle_mobile {
 
   private:
     void CheckAllInputOutputSet() const;
-        };
+};
 
-        template <typename Dtype>
-        class OperatorWithKernel : public OperatorBase<Dtype> {
+template <typename Dtype>
+class OperatorWithKernel : public OperatorBase<Dtype> {
   public:
-            OperatorWithKernel(const std::string &type,
-                               const VariableNameMap &inputs,
+    OperatorWithKernel(const std::string &type, const VariableNameMap &inputs,
                        const VariableNameMap &outputs,
-                               const AttributeMap &attrs,
-                               std::shared_ptr<Scope> scope)
+                       const AttributeMap &attrs, std::shared_ptr<Scope> scope)
         : OperatorBase<Dtype>(type, inputs, outputs, attrs, scope) {}
     virtual void InferShape() const = 0;
     virtual void Run() const = 0;
-        };
+};
 
-        template <typename Dtype, typename P>
-        class OpKernelBase : PaddleMobileObject {
+template <typename Dtype, typename P> class OpKernelBase : PaddleMobileObject {
   public:
     virtual void Compute(const P &para) const = 0;
 
     virtual ~OpKernelBase() = default;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/paddle_mobile_object.h

@@ -23,7 +23,7 @@ SOFTWARE.
 
 namespace paddle_mobile {
 
-    class PaddleMobileObject {
+class PaddleMobileObject {
   public:
     virtual inline const std::string &ToString() {
         char address[128] = {0};
@@ -32,5 +32,5 @@ namespace paddle_mobile {
     }
 
   private:
-    };
+};
 } // namespace paddle_mobile

src/framework/program.cpp

@@ -17,5 +17,5 @@ SOFTWARE.
 ==============================================================================*/
 
 namespace paddle_mobile {
-    namespace framework {}
+namespace framework {}
 } // namespace paddle_mobile

src/framework/program.h

@@ -24,17 +24,17 @@ SOFTWARE.
 #include "scope.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype, Precision P = Precision::FP32>
-        class Program : PaddleMobileObject {
+template <typename Dtype, Precision P = Precision::FP32>
+class Program : PaddleMobileObject {
   public:
     std::shared_ptr<ProgramDesc> originProgram;
     std::shared_ptr<ProgramDesc> optimizeProgram;
     std::shared_ptr<Scope> scope;
 
   private:
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/program_desc.cpp

@@ -5,18 +5,18 @@
 #include "program_desc.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        ProgramDesc::ProgramDesc(const proto::ProgramDesc &desc) : desc_(desc) {
+ProgramDesc::ProgramDesc(const proto::ProgramDesc &desc) : desc_(desc) {
     for (auto &block_desc : *desc_.mutable_blocks()) {
         // new framework::BlockDesc(block_desc)
         blocks_.emplace_back(std::make_shared<BlockDesc>(block_desc));
     }
-        }
+}
 
-        std::shared_ptr<BlockDesc> ProgramDesc::Block(size_t idx) {
+std::shared_ptr<BlockDesc> ProgramDesc::Block(size_t idx) {
     return blocks_[idx];
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/program_desc.h

@@ -25,20 +25,18 @@ SOFTWARE.
 #include "paddle_mobile_object.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        class ProgramDesc : PaddleMobileObject {
+class ProgramDesc : PaddleMobileObject {
   public:
     ProgramDesc(const proto::ProgramDesc &desc);
     std::shared_ptr<BlockDesc> Block(size_t idx);
-            const std::vector<std::shared_ptr<BlockDesc>> &Blocks() {
-                return blocks_;
-            };
+    const std::vector<std::shared_ptr<BlockDesc>> &Blocks() { return blocks_; };
 
   private:
     std::vector<std::shared_ptr<BlockDesc>> blocks_;
     proto::ProgramDesc desc_;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/scope.cc

@@ -4,15 +4,15 @@
 #include <vector>
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        Scope &Scope::NewScope() const {
+Scope &Scope::NewScope() const {
     std::unique_lock<std::mutex> lock(mutex_);
     kids_.push_back(new Scope(this));
     return *kids_.back();
-        }
+}
 
-        Variable *Scope::Var(const std::string &name) {
+Variable *Scope::Var(const std::string &name) {
     auto *pvar = FindVarLocally(name);
     if (pvar != nullptr) {
         return pvar;
@@ -21,59 +21,59 @@ namespace paddle_mobile {
     vars_[name] = pvar;
     pvar->name_ = &(vars_.find(name)->first);
     return pvar;
-        }
+}
 
-        //            Variable* Scope::Var(std::string* name) {
-        //                auto var_name = string::Sprintf("%p.%d", this,
-        //                vars_.size());
-        //                if (name != nullptr) {
-        //                    *name = var_name;
-        //                }
-        //                return Var(var_name);
-        //            }
+//            Variable* Scope::Var(std::string* name) {
+//                auto var_name = string::Sprintf("%p.%d", this,
+//                vars_.size());
+//                if (name != nullptr) {
+//                    *name = var_name;
+//                }
+//                return Var(var_name);
+//            }
 
-        Variable *Scope::FindVar(const std::string &name) const {
+Variable *Scope::FindVar(const std::string &name) const {
     auto *pvar = FindVarLocally(name);
     if (pvar != nullptr) {
         return pvar;
     }
     return (parent_ == nullptr) ? nullptr : parent_->FindVar(name);
-        }
+}
 
-        const Scope *Scope::FindScope(const Variable *var) const {
+const Scope *Scope::FindScope(const Variable *var) const {
     for (auto &name_var : vars_) {
         if (name_var.second == var) {
             return this;
         }
     }
     return (parent_ == nullptr) ? nullptr : parent_->FindScope(var);
-        }
+}
 
-        void Scope::DropKids() {
+void Scope::DropKids() {
     for (Scope *s : kids_) {
         delete s;
     }
     kids_.clear();
-        }
+}
 
-        std::vector<std::string> Scope::LocalVarNames() const {
+std::vector<std::string> Scope::LocalVarNames() const {
     std::vector<std::string> known_vars;
     known_vars.reserve(vars_.size());
     for (auto &name_var : vars_) {
         known_vars.emplace_back(name_var.first);
     }
     return known_vars;
-        }
+}
 
-        void Scope::DeleteScope(Scope *scope) const {
+void Scope::DeleteScope(Scope *scope) const {
     std::unique_lock<std::mutex> lock(mutex_);
     auto it = std::find(kids_.begin(), kids_.end(), scope);
     kids_.erase(it);
     delete scope;
     // deferent
-        }
+}
 
-        void Scope::EraseVars(const std::vector<std::string> &var_names) {
+void Scope::EraseVars(const std::vector<std::string> &var_names) {
     std::set<std::string> var_set(var_names.begin(), var_names.end());
     for (auto it = vars_.begin(); it != vars_.end();) {
         if (var_set.find(it->first) != var_set.end()) {
@@ -83,9 +83,9 @@ namespace paddle_mobile {
             ++it;
         }
     }
-        }
+}
 
-        void Scope::Rename(const std::string &origin_name,
+void Scope::Rename(const std::string &origin_name,
                    const std::string &new_name) const {
     auto origin_it = vars_.find(origin_name);
     if (origin_it == vars_.end()) {
@@ -97,23 +97,23 @@ namespace paddle_mobile {
     }
     vars_[new_name] = origin_it->second;
     vars_.erase(origin_it);
-        }
-        //
-        //            std::string Scope::Rename(const std::string& origin_name)
-        //            const {
-        //                auto var_name = string::Sprintf("%p.%d", this,
-        //                vars_.size());
-        //                Rename(origin_name, var_name);
-        //                return var_name;
-        //            }
+}
+//
+//            std::string Scope::Rename(const std::string& origin_name)
+//            const {
+//                auto var_name = string::Sprintf("%p.%d", this,
+//                vars_.size());
+//                Rename(origin_name, var_name);
+//                return var_name;
+//            }
 
-        Variable *Scope::FindVarLocally(const std::string &name) const {
+Variable *Scope::FindVarLocally(const std::string &name) const {
     auto it = vars_.find(name);
     if (it != vars_.end()) {
         return it->second;
     }
     return nullptr;
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/scope.h

@@ -24,8 +24,8 @@ SOFTWARE.
 #include <unordered_map> //std::unordered_map
 
 namespace paddle_mobile {
-    namespace framework {
-        class Scope {
+namespace framework {
+class Scope {
   public:
     Scope() {}
     ~Scope() {}
@@ -76,6 +76,6 @@ namespace paddle_mobile {
     Scope const *parent_{nullptr};
 
     mutable std::mutex mutex_;
-        };
-    } // namespace framework
+};
+} // namespace framework
 } // namespace paddle_mobile

src/framework/selected_rows.h

@@ -24,12 +24,11 @@ SOFTWARE.
 #include "tensor.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        class SelectedRows {
+class SelectedRows {
   public:
-            SelectedRows(const std::vector<int64_t> &rows,
-                         const int64_t &height)
+    SelectedRows(const std::vector<int64_t> &rows, const int64_t &height)
         : rows_(rows), height_(height) {
         value_.reset(new Tensor());
     }
@@ -76,7 +75,7 @@ namespace paddle_mobile {
     std::vector<int64_t> rows_;
     std::unique_ptr<Tensor> value_{nullptr};
     int64_t height_;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/tensor.h

@@ -25,10 +25,10 @@ limitations under the License. */
 #include "memory/t_malloc.h"
 
 namespace paddle_mobile {
-    namespace framework {
-        template <typename... T> struct SizeOfTypeFunctor;
+namespace framework {
+template <typename... T> struct SizeOfTypeFunctor;
 
-        template <typename T> struct SizeOfTypeFunctor<T> {
+template <typename T> struct SizeOfTypeFunctor<T> {
     size_t operator()(std::type_index type) const {
         if (typeid(T).hash_code() == type.hash_code()) {
             return sizeof(T);
@@ -36,14 +36,14 @@ namespace paddle_mobile {
             return 0UL;
         }
     }
-        };
+};
 
-        template <> struct SizeOfTypeFunctor<> {
+template <> struct SizeOfTypeFunctor<> {
     size_t operator()(std::type_index type) const { return 0UL; }
-        };
+};
 
-        template <typename HEAD, typename... TAIL>
-        struct SizeOfTypeFunctor<HEAD, TAIL...> {
+template <typename HEAD, typename... TAIL>
+struct SizeOfTypeFunctor<HEAD, TAIL...> {
     size_t operator()(std::type_index type) const {
         SizeOfTypeFunctor<HEAD> head;
         size_t head_size = head(type);
@@ -53,21 +53,20 @@ namespace paddle_mobile {
         SizeOfTypeFunctor<TAIL...> tail;
         return tail(type);
     }
-        };
+};
 
-        static inline size_t SizeOfType(std::type_index type) {
-            SizeOfTypeFunctor<int, float, double, int16_t, int64_t, bool,
-                              size_t>
+static inline size_t SizeOfType(std::type_index type) {
+    SizeOfTypeFunctor<int, float, double, int16_t, int64_t, bool, size_t>
         functor;
     size_t size = functor(type);
     //  PADDLE_ENFORCE(size != 0UL, "Cannot get size of type %s",
     //  type.name());
     return size;
-        }
+}
 
-        class LoDTensor;
+class LoDTensor;
 
-        class Tensor {
+class Tensor {
   public:
     Tensor() : offset_(0) {}
 
@@ -200,8 +199,7 @@ namespace paddle_mobile {
             DDim dst_dims = dims_;
             dst_dims[0] = end_idx - begin_idx;
             dst.Resize(dst_dims);
-                    dst.offset_ =
-                        offset_ + begin_idx * base * SizeOfType(type());
+            dst.offset_ = offset_ + begin_idx * base * SizeOfType(type());
             return dst;
         }
     }
@@ -236,9 +234,7 @@ namespace paddle_mobile {
 
     inline DataLayout layout() const { return layout_; }
 
-            inline void set_layout(const DataLayout layout) {
-                layout_ = layout;
-            }
+    inline void set_layout(const DataLayout layout) { layout_ = layout; }
 
   private:
     /**
@@ -274,9 +270,7 @@ namespace paddle_mobile {
 
         virtual size_t size() const { return size_; }
 
-                virtual void *ptr() const {
-                    return static_cast<void *>(ptr_.get());
-                }
+        virtual void *ptr() const { return static_cast<void *>(ptr_.get()); }
 
         virtual std::type_index type() const { return type_; }
 
@@ -327,14 +321,14 @@ namespace paddle_mobile {
      * begins.
      */
     size_t offset_;
-        };
+};
 
-        inline Tensor ReshapeToMatrix(const Tensor &src, int num_col_dims) {
+inline Tensor ReshapeToMatrix(const Tensor &src, int num_col_dims) {
     Tensor res;
     res.ShareDataWith(src);
     res.Resize(flatten_to_2d(src.dims(), num_col_dims));
     return res;
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/tensor_util.cc

@@ -18,9 +18,9 @@
 #include <vector>
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        void TensorCopy(const Tensor &src, Tensor *dst) {
+void TensorCopy(const Tensor &src, Tensor *dst) {
     //  VLOG(3) << "TensorCopy " << src.dims() << " from " <<
     //  src.place() << " to
     //  "
@@ -36,9 +36,9 @@ namespace paddle_mobile {
     auto size = src.numel() * SizeOfType(src.type());
 
     memory::Copy(dst_ptr, src_ptr, size);
-        }
+}
 
-        void TensorCopySync(const Tensor &src, Tensor *dst) {
+void TensorCopySync(const Tensor &src, Tensor *dst) {
     //  VLOG(3) << "TensorCopySync " << src.dims() << " from " <<
     //  src.place()
     //          << " to " << dst_place;
@@ -49,15 +49,14 @@ namespace paddle_mobile {
     auto dst_ptr = dst->mutable_data(src.type());
     auto size = src.numel() * SizeOfType(src.type());
     memory::Copy(dst_ptr, src_ptr, size);
-        }
+}
 
-        template <typename Predicate> struct AnyDTypeVisitor {
+template <typename Predicate> struct AnyDTypeVisitor {
     Predicate predicate_;
     const Tensor &tensor_;
     Tensor *out_;
 
-            AnyDTypeVisitor(Predicate predicate, const Tensor &tensor,
-                            Tensor *out)
+    AnyDTypeVisitor(Predicate predicate, const Tensor &tensor, Tensor *out)
         : predicate_(predicate), tensor_(tensor), out_(out) {}
 
     template <typename T> void operator()() const {
@@ -66,16 +65,16 @@ namespace paddle_mobile {
         // return any of predicate_(t) is true.
         //    o.device(*ctx_.eigen_device()) = predicate_(t).any();
     }
-        };
+};
 
-        template <typename Predicate>
-        inline void AnyImpl(Predicate predicate, const Tensor &tensor,
+template <typename Predicate>
+inline void AnyImpl(Predicate predicate, const Tensor &tensor,
                     framework::Tensor *out) {
     VisitDataType(ToDataType(tensor.type()),
                   AnyDTypeVisitor<Predicate>(predicate, tensor, out));
-        }
+}
 
-        template <typename Predicate> struct AnyVisitor {
+template <typename Predicate> struct AnyVisitor {
     const framework::Tensor &tensor_;
     Predicate predicate_;
 
@@ -93,48 +92,47 @@ namespace paddle_mobile {
     bool GetResult(const framework::Tensor &out) const {
         return *out.data<bool>();
     }
-        };
+};
 
-        template <typename Predicate>
-        inline bool Any(const framework::Tensor &tensor, Predicate predicate) {
+template <typename Predicate>
+inline bool Any(const framework::Tensor &tensor, Predicate predicate) {
     AnyVisitor<Predicate> visitor(tensor, predicate);
     //  return platform::VisitPlace(visitor);
     return visitor();
-        }
+}
 
-        struct ContainsNANPredicate {
+struct ContainsNANPredicate {
     template <typename T>
     auto operator()(const T &eigen_vec) const
         -> decltype(std::declval<T>().isnan()) {
         // Cast eigen_vector to vector of bool. true if is inf.
         return eigen_vec.isnan();
     }
-        };
+};
 
-        bool TensorContainsNAN(const framework::Tensor &tensor) {
+bool TensorContainsNAN(const framework::Tensor &tensor) {
     ContainsNANPredicate predicate;
     return Any(tensor, predicate);
-        }
+}
 
-        struct ContainsInfPredicate {
+struct ContainsInfPredicate {
     template <typename T>
     auto operator()(const T &eigen_vec) const
         -> decltype(std::declval<T>().isinf()) {
         // Cast eigen_vector to vector of bool. true if is inf.
         return eigen_vec.isinf();
     }
-        };
+};
 
-        bool TensorContainsInf(const framework::Tensor &tensor) {
+bool TensorContainsInf(const framework::Tensor &tensor) {
     ContainsInfPredicate predicate;
     return Any(tensor, predicate);
-        }
+}
 
-        void TensorToStream(std::ostream &os, const Tensor &tensor) {
+void TensorToStream(std::ostream &os, const Tensor &tensor) {
     { // the 1st field, uint32_t version
         constexpr uint32_t version = 0;
-                os.write(reinterpret_cast<const char *>(&version),
-                         sizeof(version));
+        os.write(reinterpret_cast<const char *>(&version), sizeof(version));
     }
     { // the 2nd field, tensor description
         // int32_t  size
@@ -160,9 +158,9 @@ namespace paddle_mobile {
         os.write(static_cast<const char *>(data_ptr),
                  static_cast<std::streamsize>(size));
     }
-        }
+}
 
-        struct DeserializedDataFunctor {
+struct DeserializedDataFunctor {
     DeserializedDataFunctor(void **buf, Tensor *tensor)
         : buf_(buf), tensor_(tensor) {}
 
@@ -172,9 +170,9 @@ namespace paddle_mobile {
 
     void **buf_;
     Tensor *tensor_;
-        };
+};
 
-        void TensorFromStream(std::istream &is, framework::Tensor *tensor) {
+void TensorFromStream(std::istream &is, framework::Tensor *tensor) {
     uint32_t version;
     is.read(reinterpret_cast<char *>(&version), sizeof(version));
     //  PADDLE_ENFORCE_EQ(version, 0U, "Only version 0 is supported");
@@ -200,7 +198,7 @@ namespace paddle_mobile {
                                  DeserializedDataFunctor(&buf, tensor));
         is.read(static_cast<char *>(buf), tensor->memory_size());
     }
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/tensor_util.h

@@ -20,39 +20,39 @@ limitations under the License. */
 #include <vector>
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        void TensorCopy(const Tensor &src, Tensor *dst);
-        void TensorCopySync(const Tensor &src, Tensor *dst);
+void TensorCopy(const Tensor &src, Tensor *dst);
+void TensorCopySync(const Tensor &src, Tensor *dst);
 
-        template <typename T>
-        void TensorFromVector(const std::vector<T> &src, Tensor *dst);
+template <typename T>
+void TensorFromVector(const std::vector<T> &src, Tensor *dst);
 
-        template <typename T>
-        void TesnorToVector(const Tensor &src, std::vector<T> *dst);
+template <typename T>
+void TesnorToVector(const Tensor &src, std::vector<T> *dst);
 
-        bool TensorContainsNAN(const framework::Tensor &tensor);
-        bool TensorContainsInf(const framework::Tensor &tensor);
+bool TensorContainsNAN(const framework::Tensor &tensor);
+bool TensorContainsInf(const framework::Tensor &tensor);
 
-        void TensorToStream(std::ostream &os, const Tensor &tensor);
-        void TensorFromStream(std::istream &is, Tensor *tensor);
+void TensorToStream(std::ostream &os, const Tensor &tensor);
+void TensorFromStream(std::istream &is, Tensor *tensor);
 
-        //
-        // The implementation of template functions.
-        //
+//
+// The implementation of template functions.
+//
 
-        template <typename T>
-        void TensorFromVector(const std::vector<T> &src, Tensor *dst) {
+template <typename T>
+void TensorFromVector(const std::vector<T> &src, Tensor *dst) {
     auto src_ptr = static_cast<const void *>(src.data());
     dst->Resize({static_cast<int64_t>(src.size())});
     auto dst_ptr = static_cast<void *>(dst->mutable_data<T>());
     auto size = src.size() * sizeof(T);
 
     memory::Copy(dst_ptr, src_ptr, size);
-        }
+}
 
-        template <typename T>
-        void TensorToVector(const Tensor &src, std::vector<T> *dst) {
+template <typename T>
+void TensorToVector(const Tensor &src, std::vector<T> *dst) {
     auto src_ptr = static_cast<const void *>(src.data<T>());
     auto size = src.numel() * sizeof(T);
 
@@ -60,7 +60,7 @@ namespace paddle_mobile {
     auto dst_ptr = static_cast<void *>(dst->data());
 
     memory::Copy(dst_ptr, src_ptr, size);
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/var_desc.cpp

@@ -20,9 +20,9 @@ SOFTWARE.
 
 namespace paddle_mobile {
 
-    namespace framework {
+namespace framework {
 
-        VarDesc::VarDesc(const proto::VarDesc &desc) : desc_(desc) {}
+VarDesc::VarDesc(const proto::VarDesc &desc) : desc_(desc) {}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/var_desc.h

@@ -22,9 +22,9 @@ SOFTWARE.
 #include "paddle_mobile_object.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        class VarDesc {
+class VarDesc {
   public:
     VarDesc(const proto::VarDesc &desc);
 
@@ -68,8 +68,7 @@ namespace paddle_mobile {
 
     template <typename T>
     std::vector<T> RepeatedToVector(
-                const google::protobuf::RepeatedField<T> &repeated_field)
-                const {
+        const google::protobuf::RepeatedField<T> &repeated_field) const {
         std::vector<T> ret;
         ret.reserve(repeated_field.size());
         std::copy(repeated_field.begin(), repeated_field.end(),
@@ -83,7 +82,7 @@ namespace paddle_mobile {
 
   private:
     proto::VarDesc desc_;
-        };
+};
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/var_type.h

@@ -23,8 +23,8 @@ SOFTWARE.
 #include "variable.h"
 
 namespace paddle_mobile {
-    namespace framework {
-        inline proto::VarType::Type ToVarType(std::type_index type) {
+namespace framework {
+inline proto::VarType::Type ToVarType(std::type_index type) {
     if (type.hash_code() == typeid(LoDTensor).hash_code()) {
         return proto::VarType_Type_LOD_TENSOR;
     } else if (type.hash_code() == typeid(SelectedRows).hash_code()) {
@@ -33,7 +33,7 @@ namespace paddle_mobile {
         //    PADDLE_THROW("ToVarType:Unsupported type %s",
         //    type.name());
     }
-        }
+}
 
-    } // namespace framework
+} // namespace framework
 } // namespace paddle_mobile

src/framework/variable.h

@@ -26,8 +26,8 @@ SOFTWARE.
 #include <typeinfo>
 
 namespace paddle_mobile {
-    namespace framework {
-        class Variable : public PaddleMobileObject {
+namespace framework {
+class Variable : public PaddleMobileObject {
   public:
     template <typename T> const T *Get() const {
         return static_cast<const T *>(holder_->Ptr());
@@ -51,8 +51,8 @@ namespace paddle_mobile {
     template <typename T> bool IsType() const {
         if (holder_) {
             //                printf("not null \n");
-                    printf(" holder type : %s, this type %s \n",
-                           holder_->Type().name(), typeid(T).name());
+            printf(" holder type : %s, this type %s \n", holder_->Type().name(),
+                   typeid(T).name());
         }
 
         //              std::cout << " " << holder_->Type() << " " <<
@@ -91,6 +91,6 @@ namespace paddle_mobile {
     std::unique_ptr<Placeholder> holder_;
     friend class Scope;
     const std::string *name_;
-        };
-    } // namespace framework
+};
+} // namespace framework
 } // namespace paddle_mobile

src/io.cpp

@@ -28,7 +28,7 @@ SOFTWARE.
 
 namespace paddle_mobile {
 
-    void ReadBinaryFile(const std::string &filename, std::string *contents) {
+void ReadBinaryFile(const std::string &filename, std::string *contents) {
     std::ifstream fin(filename, std::ios::in | std::ios::binary);
     fin.seekg(0, std::ios::end);
     contents->clear();
@@ -36,10 +36,10 @@ namespace paddle_mobile {
     fin.seekg(0, std::ios::beg);
     fin.read(&(contents->at(0)), contents->size());
     fin.close();
-    }
+}
 
-    template <typename Dtype, Precision P>
-    void Loader<Dtype, P>::LoadVar(framework::LoDTensor *tensor,
+template <typename Dtype, Precision P>
+void Loader<Dtype, P>::LoadVar(framework::LoDTensor *tensor,
                                const std::string &file_path) {
     //        LOG(kLOG_DEBUG) << "  to load " << file_path;
     //  Log(kLOG_DEBUG) << "123";
@@ -77,8 +77,7 @@ namespace paddle_mobile {
 
     // 3. tensor version
     uint32_t tensor_version;
-        is.read(reinterpret_cast<char *>(&tensor_version),
-                sizeof(tensor_version));
+    is.read(reinterpret_cast<char *>(&tensor_version), sizeof(tensor_version));
     //  std::cout << "   tensor_version: " << tensor_version << std::endl;
 
     // 4. tensor desc
@@ -103,8 +102,7 @@ namespace paddle_mobile {
 
     std::vector<int64_t> dims;
     dims.reserve(static_cast<size_t>(desc.dims().size()));
-        std::copy(desc.dims().begin(), desc.dims().end(),
-                  std::back_inserter(dims));
+    std::copy(desc.dims().begin(), desc.dims().end(), std::back_inserter(dims));
     tensor->Resize(framework::make_ddim(dims));
 
     void *memory;
@@ -146,11 +144,11 @@ namespace paddle_mobile {
     is.read(static_cast<char *>(memory), memory_size * type_size);
     //  std::cout << "    memory: " << memory << std::endl;
     is.close();
-    };
+};
 
-    template <typename Dtype, Precision P>
-    const framework::Program<Dtype, P>
-    Loader<Dtype, P>::Load(const std::string &dirname) {
+template <typename Dtype, Precision P>
+const framework::Program<Dtype, P>
+Loader<Dtype, P>::Load(const std::string &dirname) {
     std::string model_filename = dirname + "/__model__";
     std::string program_desc_str;
     ReadBinaryFile(model_filename, &program_desc_str);
@@ -174,8 +172,7 @@ namespace paddle_mobile {
         for (int i = 0; i < block->Vars().size(); ++i) {
             std::shared_ptr<framework::VarDesc> var_desc = block->Vars()[i];
             auto var = scope->Var(var_desc->Name());
-                if (var_desc->GetType() ==
-                    framework::proto::VarType::LOD_TENSOR) {
+            if (var_desc->GetType() == framework::proto::VarType::LOD_TENSOR) {
                 if (var_desc->Persistable() &&
                     var_desc->GetType() !=
                         framework::proto::VarType::FEED_MINIBATCH &&
@@ -201,11 +198,9 @@ namespace paddle_mobile {
             LOG(kLOG_DEBUG1) << " op: " << op.type();
             for (int m = 0; m < op.inputs_size(); ++m) {
                 const framework::proto::OpDesc::Var &var = op.inputs(m);
-                    LOG(kLOG_DEBUG2) << "  input parameter: "
-                                     << var.parameter();
+                LOG(kLOG_DEBUG2) << "  input parameter: " << var.parameter();
                 for (int n = 0; n < var.arguments().size(); ++n) {
-                        LOG(kLOG_DEBUG3) << "   argument - "
-                                         << var.arguments()[n];
+                    LOG(kLOG_DEBUG3) << "   argument - " << var.arguments()[n];
                 }
             }
 
@@ -213,8 +208,7 @@ namespace paddle_mobile {
                 const framework::proto::OpDesc::Var &var = op.outputs(y);
                 LOG(kLOG_DEBUG2) << "  out parameter: " << var.parameter();
                 for (int z = 0; z < var.arguments().size(); ++z) {
-                        LOG(kLOG_DEBUG3) << "   argument - "
-                                         << var.arguments()[z];
+                    LOG(kLOG_DEBUG3) << "   argument - " << var.arguments()[z];
                 }
             }
 
@@ -278,8 +272,7 @@ namespace paddle_mobile {
 
         for (int k = 0; k < block.vars().size(); ++k) {
             framework::proto::VarDesc var = block.vars()[k];
-                if (var.type().type() ==
-                    framework::proto::VarType::LOD_TENSOR) {
+            if (var.type().type() == framework::proto::VarType::LOD_TENSOR) {
                 //        std::cout << " var name: " << var.name() <<
                 //        std::endl;
                 const framework::proto::VarType::TensorDesc &tensor_desc =
@@ -299,14 +292,12 @@ namespace paddle_mobile {
             if (var.persistable() &&
                 var.type().type() !=
                     framework::proto::VarType::FEED_MINIBATCH &&
-                    var.type().type() !=
-                        framework::proto::VarType::FETCH_LIST) {
+                var.type().type() != framework::proto::VarType::FETCH_LIST) {
                 //        std::cout << "  to load " << var.name() <<
                 //        std::endl;
                 std::string file_path = dirname + "/" + var.name();
                 std::ifstream is(file_path);
-                    std::streampos pos =
-                        is.tellg(); //   save   current   position
+                std::streampos pos = is.tellg(); //   save   current   position
                 is.seekg(0, std::ios::end);
                 //        std::cout << "  file length = " << is.tellg() <<
                 //        std::endl;
@@ -314,8 +305,7 @@ namespace paddle_mobile {
 
                 // 1. version
                 uint32_t version;
-                    is.read(reinterpret_cast<char *>(&version),
-                            sizeof(version));
+                is.read(reinterpret_cast<char *>(&version), sizeof(version));
                 //        std::cout << "   version: " << version <<
                 //        std::endl;
 
@@ -339,8 +329,7 @@ namespace paddle_mobile {
                 }
 
                 uint32_t tensor_version;
-                    is.read(reinterpret_cast<char *>(&version),
-                            sizeof(version));
+                is.read(reinterpret_cast<char *>(&version), sizeof(version));
                 //        std::cout << "   tensor_version: " <<
                 //        tensor_version <<
                 //        std::endl;
@@ -404,8 +393,7 @@ namespace paddle_mobile {
                 //        type_size
                 //                  << std::endl;
                 void *memory = malloc(memory_size * type_size);
-                    is.read(static_cast<char *>(memory),
-                            memory_size * type_size);
+                is.read(static_cast<char *>(memory), memory_size * type_size);
                 //        std::cout << "    memory: " << memory <<
                 //        std::endl;
                 is.close();
@@ -418,8 +406,8 @@ namespace paddle_mobile {
 
 #endif
     return program;
-    }
+}
 
-    template class Loader<CPU, Precision::FP32>;
+template class Loader<CPU, Precision::FP32>;
 
 } // namespace paddle_mobile

src/io.h

@@ -27,14 +27,13 @@ SOFTWARE.
 
 namespace paddle_mobile {
 
-    template <typename Dtype, Precision P = Precision::FP32>
-    class Loader : PaddleMobileObject {
+template <typename Dtype, Precision P = Precision::FP32>
+class Loader : PaddleMobileObject {
   public:
     const framework::Program<Dtype, P> Load(const std::string &dirname);
 
   private:
-        void LoadVar(framework::LoDTensor *tensor,
-                     const std::string &file_path);
-    };
+    void LoadVar(framework::LoDTensor *tensor, const std::string &file_path);
+};
 
 } // namespace paddle_mobile

src/memory/t_malloc.cc

@@ -22,30 +22,30 @@ SOFTWARE.
 #include <cstring>
 
 namespace paddle_mobile {
-    namespace memory {
-        const int MALLOC_ALIGN = 16;
+namespace memory {
+const int MALLOC_ALIGN = 16;
 
-        void Copy(void *dst, const void *src, size_t num) {
+void Copy(void *dst, const void *src, size_t num) {
     std::memcpy(dst, src, num);
-        };
+};
 
-        void *Alloc(size_t size) {
+void *Alloc(size_t size) {
     size_t offset = sizeof(void *) + MALLOC_ALIGN - 1;
     char *p = static_cast<char *>(malloc(offset + size));
     if (!p) {
         return nullptr;
     }
-            void *r = reinterpret_cast<void *>(
-                reinterpret_cast<size_t>(p + offset) & (~(MALLOC_ALIGN - 1)));
+    void *r = reinterpret_cast<void *>(reinterpret_cast<size_t>(p + offset) &
+                                       (~(MALLOC_ALIGN - 1)));
     static_cast<void **>(r)[-1] = p;
     return r;
-        }
+}
 
-        void Free(void *ptr) {
+void Free(void *ptr) {
     if (ptr) {
         free(static_cast<void **>(ptr)[-1]);
     }
-        }
+}
 
-    } // namespace memory
+} // namespace memory
 } // namespace paddle_mobile

src/memory/t_malloc.h

@@ -21,15 +21,15 @@ SOFTWARE.
 #include <type_traits>
 
 namespace paddle_mobile {
-    namespace memory {
+namespace memory {
 
-        void Copy(void *dst, const void *src, size_t num);
+void Copy(void *dst, const void *src, size_t num);
 
-        void *Alloc(size_t size);
+void *Alloc(size_t size);
 
-        void Free(void *ptr);
+void Free(void *ptr);
 
-        /**
+/**
  * \brief   Free memory block in one place.
  *
  * \note    In some cases, custom deleter is used to
@@ -37,16 +37,16 @@ namespace paddle_mobile {
  *          std::unique_ptr<T> in tensor.h.
  *          static_cast
  */
-        template <typename T> class PODDeleter {
+template <typename T> class PODDeleter {
     static_assert(std::is_pod<T>::value, "T must be POD");
 
   public:
     explicit PODDeleter(){};
 
     void operator()(T *ptr) { Free(static_cast<void *>(ptr)); }
-        };
+};
 
-        /**
+/**
  * \brief   Free memory block in one place does not meet POD
  *
  * \note    In some cases, custom deleter is used to
@@ -54,11 +54,11 @@ namespace paddle_mobile {
  *          std::unique_ptr<T> in tensor.h.
  *          reinterpret_cast
  */
-        template <typename T> class PlainDeleter {
+template <typename T> class PlainDeleter {
   public:
     explicit PlainDeleter(){};
 
     void operator()(T *ptr) { Free(reinterpret_cast<void *>(ptr)); }
-        };
-    } // namespace memory
+};
+} // namespace memory
 } // namespace paddle_mobile

src/operators/conv_op.cpp

@@ -23,14 +23,14 @@ SOFTWARE.
 namespace paddle_mobile {
 namespace operators {
 
-int ConvOutputSize(int input_size, int filter_size, int dilation,
-                   int padding, int stride) {
+int ConvOutputSize(int input_size, int filter_size, int dilation, int padding,
+                   int stride) {
     const int dkernel = dilation * (filter_size - 1) + 1;
     int output_size = (input_size + 2 * padding - dkernel) / stride + 1;
     return output_size;
 }
 
-template<typename Dtype, typename T>
+template <typename Dtype, typename T>
 void ConvOp<Dtype, T>::InferShape() const {
     //  std::cout << " begin get dims: " << std::endl;
 
@@ -60,9 +60,9 @@ void ConvOp<Dtype, T>::InferShape() const {
 
     std::vector<int64_t> output_shape({in_dims[0], filter_dims[0]});
     for (size_t i = 0; i < strides.size(); ++i) {
-    output_shape.push_back(
-        ConvOutputSize(in_dims[i + 2], filter_dims[i + 2],
-                       dilations[i], paddings[i], strides[i]));
+        output_shape.push_back(ConvOutputSize(in_dims[i + 2],
+                                              filter_dims[i + 2], dilations[i],
+                                              paddings[i], strides[i]));
     }
 
     framework::DDim ddim = framework::make_ddim(output_shape);

src/operators/conv_op.h

@@ -26,15 +26,14 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T>
+template <typename DeviceType, typename T>
 class ConvOp : public framework::OperatorWithKernel<DeviceType> {
-public:
+  public:
     ConvOp(const std::string &type, const VariableNameMap &inputs,
-         const VariableNameMap &outputs,
-         const framework::AttributeMap &attrs,
+           const VariableNameMap &outputs, const framework::AttributeMap &attrs,
            std::shared_ptr<framework::Scope> scope)
-      : framework::OperatorWithKernel<DeviceType>(
-      type, inputs, outputs, attrs, scope),
+        : framework::OperatorWithKernel<DeviceType>(type, inputs, outputs,
+                                                    attrs, scope),
           param_(inputs, outputs, attrs, *scope) {}
 
     using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
@@ -46,9 +45,9 @@ public:
         this->ClearVariables();
     }
 
-private:
+  private:
     ConvParam param_;
 };
 
-} // operators
-} // paddle_mobile
+} // namespace operators
+} // namespace paddle_mobile

src/operators/elementwise_add_op.cpp

@@ -21,11 +21,11 @@ SOFTWARE.
 namespace paddle_mobile {
 namespace operators {
 
-template<typename Dtype, typename T>
+template <typename Dtype, typename T>
 void ElementwiseAddOp<Dtype, T>::InferShape() const {
     auto x_dim = param_.InputX()->dims();
     param_.Out()->Resize(x_dim);
 }
 template class ElementwiseAddOp<CPU, float>;
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/elementwise_add_op.h

@@ -25,22 +25,19 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T>
-class ElementwiseAddOp
-    : public framework::OperatorWithKernel<DeviceType> {
-public:
-  ElementwiseAddOp(const std::string &type,
-                   const VariableNameMap &inputs,
+template <typename DeviceType, typename T>
+class ElementwiseAddOp : public framework::OperatorWithKernel<DeviceType> {
+  public:
+    ElementwiseAddOp(const std::string &type, const VariableNameMap &inputs,
                      const VariableNameMap &outputs,
                      const framework::AttributeMap attrs,
                      std::shared_ptr<framework::Scope> scope)
-      : framework::OperatorWithKernel<DeviceType>(
-      type, inputs, outputs, attrs, scope),
+        : framework::OperatorWithKernel<DeviceType>(type, inputs, outputs,
+                                                    attrs, scope),
           param_(inputs, outputs, attrs, *scope) {}
 
     void Run() const {
-    operators::ElementwiseAddKernel<DeviceType, T,
-                                    ElementwiseAddParam>
+        operators::ElementwiseAddKernel<DeviceType, T, ElementwiseAddParam>
             kernel;
         kernel.Compute(param_);
     }
@@ -48,8 +45,8 @@ public:
     using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
     void InferShape() const override;
 
-protected:
+  protected:
     ElementwiseAddParam param_;
 };
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/kernel/arm/conv_kernel.cpp

@@ -22,14 +22,11 @@ namespace paddle_mobile {
 namespace operators {
 
 bool IsExpand(const std::vector<int64_t> &filter_dim,
-              const std::vector<int> &strides,
-              const std::vector<int> &paddings,
+              const std::vector<int> &strides, const std::vector<int> &paddings,
               const std::vector<int> &dilations) {
-  bool filter_1 = true, strides_1 = true, padding_0 = true,
-      dilation_1 = true;
+    bool filter_1 = true, strides_1 = true, padding_0 = true, dilation_1 = true;
     for (size_t j = 0; j < strides.size(); ++j) {
-    filter_1 =
-        filter_1 && (static_cast<int>(filter_dim[j + 2]) == 1);
+        filter_1 = filter_1 && (static_cast<int>(filter_dim[j + 2]) == 1);
         strides_1 = strides_1 && (strides[j] == 1);
         padding_0 = padding_0 && (paddings[j] == 0);
         dilation_1 = dilation_1 && (dilations[j] == 1);
@@ -37,9 +34,8 @@ bool IsExpand(const std::vector<int64_t> &filter_dim,
     return !(filter_1 && strides_1 && padding_0 && dilation_1);
 }
 
-template<>
-void ConvKernel<CPU, float, ConvParam>::Compute(
-    const ConvParam &param) const {
+template <>
+void ConvKernel<CPU, float, ConvParam>::Compute(const ConvParam &param) const {
     LOG(kLOG_DEBUG) << param;
 
     const Tensor *input = param.Input();
@@ -63,12 +59,10 @@ void ConvKernel<CPU, float, ConvParam>::Compute(
 
     // filter_shape_vec: {k_o, k_i, k_h, k_w} or {k_o, k_i, k_d, k_h,
     // k_w}
-  std::vector<int64_t> filter_shape_vec(
-      framework::vectorize(filter.dims()));
+    std::vector<int64_t> filter_shape_vec(framework::vectorize(filter.dims()));
     // output_shape_vec: {o_n, o_c, o_h, o_w} or {o_n, o_c, o_d, o_h,
     // o_w}
-  std::vector<int64_t> output_shape_vec(
-      framework::vectorize(output->dims()));
+    std::vector<int64_t> output_shape_vec(framework::vectorize(output->dims()));
 
     // use col_shape in the im2col calculation
     // col_shape_vec: {i_c/g, k_h, k_w, o_h, o_w} or {i_c/g, k_d, k_h,
@@ -90,8 +84,7 @@ void ConvKernel<CPU, float, ConvParam>::Compute(
     framework::DDim col_matrix_shape =
         framework::flatten_to_2d(col_shape, data_dim + 1);
 
-  bool is_expand =
-      IsExpand(filter_shape_vec, strides, paddings, dilations);
+    bool is_expand = IsExpand(filter_shape_vec, strides, paddings, dilations);
     Tensor col;
     // col_matrix shares the same piece of data with col,
     // but will be reshaped into a two-dimensional matrix shape
@@ -106,8 +99,8 @@ void ConvKernel<CPU, float, ConvParam>::Compute(
     framework::DDim input_shape = framework::slice_ddim(
         input->dims(), 1, static_cast<int>(input->dims().size()));
 
-  framework::DDim filter_matrix_shape = {
-      filter.dims()[0], filter.numel() / filter.dims()[0]};
+    framework::DDim filter_matrix_shape = {filter.dims()[0],
+                                           filter.numel() / filter.dims()[0]};
     filter.Resize(filter_matrix_shape);
 
     framework::DDim output_matrix_shape = {
@@ -125,12 +118,10 @@ void ConvKernel<CPU, float, ConvParam>::Compute(
     //            device_context<DeviceContext>();
     for (int i = 0; i < batch_size; i++) {
         Tensor in_batch = input->Slice(i, i + 1).Resize(input_shape);
-    Tensor out_batch =
-        output->Slice(i, i + 1).Resize(output_matrix_shape);
+        Tensor out_batch = output->Slice(i, i + 1).Resize(output_matrix_shape);
 
         for (int g = 0; g < groups; g++) {
-      Tensor in_slice =
-          in_batch.Slice(g * in_step, (g + 1) * in_step);
+            Tensor in_slice = in_batch.Slice(g * in_step, (g + 1) * in_step);
 
             if (!is_expand) {
                 col.ShareDataWith(in_slice);
@@ -139,8 +130,8 @@ void ConvKernel<CPU, float, ConvParam>::Compute(
             } else if (data_dim == 2U) {
                 // im2col
                 im2col(in_slice, dilations, strides,
-               std::vector<int>{paddings[0], paddings[1],
-                                paddings[0], paddings[1]},
+                       std::vector<int>{paddings[0], paddings[1], paddings[0],
+                                        paddings[1]},
                        &col);
             } else if (data_dim == 3U) {
                 // vol2col

src/operators/kernel/arm/elementwise_add_kernel.cpp

@@ -19,11 +19,11 @@ limitations under the License. */
 namespace paddle_mobile {
 namespace operators {
 
-template<typename T> struct AddFunctor {
+template <typename T> struct AddFunctor {
     inline T operator()(T a, T b) const { return a + b; }
 };
 
-template<>
+template <>
 void ElementwiseAddKernel<CPU, float, ElementwiseAddParam>::Compute(
     const ElementwiseAddParam &param) const {
     const Tensor *input_x = param.InputX();
@@ -31,11 +31,11 @@ void ElementwiseAddKernel<CPU, float, ElementwiseAddParam>::Compute(
     Tensor *Out = param.Out();
     Out->mutable_data<float>();
     const int axis = param.Axis();
-  ElementwiseComputeEx<AddFunctor<float>, float>(
-      input_x, input_y, axis, AddFunctor<float>(), Out);
+    ElementwiseComputeEx<AddFunctor<float>, float>(input_x, input_y, axis,
+                                                   AddFunctor<float>(), Out);
 }
 
 template class ElementwiseAddKernel<CPU, float, ElementwiseAddParam>;
 
 } // namespace operators
-} // namespace paddle
+} // namespace paddle_mobile

src/operators/kernel/arm/mul_kernel.cpp

@@ -23,9 +23,8 @@ SOFTWARE.
 namespace paddle_mobile {
 namespace operators {
 
-template<>
-void
-MulKernel<CPU, float, MulParam>::Compute(const MulParam &param) const {
+template <>
+void MulKernel<CPU, float, MulParam>::Compute(const MulParam &param) const {
     const Tensor *input_x = param.InputX();
     const Tensor *input_y = param.InputY();
     Tensor *out = param.Out();
@@ -42,9 +41,8 @@ MulKernel<CPU, float, MulParam>::Compute(const MulParam &param) const {
     if (out_dim.size() != 2) {
         out->Resize({x_matrix.dims()[0], y_matrix.dims()[1]});
     }
-  math::matmul<float>(x_matrix, false, y_matrix, false,
-                      static_cast<float>(1), out,
-                      static_cast<float>(0));
+    math::matmul<float>(x_matrix, false, y_matrix, false, static_cast<float>(1),
+                        out, static_cast<float>(0));
     if (out_dim.size() != 2) {
         out->Resize(out_dim);
     }
@@ -53,4 +51,4 @@ MulKernel<CPU, float, MulParam>::Compute(const MulParam &param) const {
 template class MulKernel<CPU, float, MulParam>;
 
 } // namespace operators
-} // namespace paddle
+} // namespace paddle_mobile

src/operators/kernel/conv_kernel.h

@@ -29,11 +29,10 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T, typename P>
-class ConvKernel
-    : public framework::OpKernelBase<DeviceType, ConvParam> {
-public:
+template <typename DeviceType, typename T, typename P>
+class ConvKernel : public framework::OpKernelBase<DeviceType, ConvParam> {
+  public:
     void Compute(const ConvParam &param) const;
 };
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/kernel/elementwise_add_kernel.h

@@ -26,11 +26,11 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T, typename P>
+template <typename DeviceType, typename T, typename P>
 class ElementwiseAddKernel
     : public framework::OpKernelBase<DeviceType, ElementwiseAddParam> {
-public:
+  public:
     void Compute(const ElementwiseAddParam &param) const;
 };
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/kernel/fpga/conv_kernel.cpp

@@ -25,4 +25,4 @@ namespace operators {
 //
 // template class ConvKernel<FPGA, float>;
 }
-}
+} // namespace paddle_mobile

src/operators/kernel/mul_kernel.h

@@ -26,10 +26,10 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T, typename P>
+template <typename DeviceType, typename T, typename P>
 class MulKernel : public framework::OpKernelBase<DeviceType, MulParam> {
-public:
+  public:
     void Compute(const MulParam &param) const;
 };
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/math/elementwise_op_function.h

@@ -68,10 +68,9 @@ inline void trim_trailing_singular_dims(framework::DDim *dims) {
     }
 }
 
-template<typename T> class RowwiseTransformIterator {
-public:
-  RowwiseTransformIterator(const T *ptr, int n)
-      : ptr_(ptr), i_(0), n_(n) {}
+template <typename T> class RowwiseTransformIterator {
+  public:
+    RowwiseTransformIterator(const T *ptr, int n) : ptr_(ptr), i_(0), n_(n) {}
 
     RowwiseTransformIterator<T> &operator++() {
         ++i_;
@@ -91,7 +90,7 @@ public:
 
     const T &operator*() { return ptr_[i_]; }
 
-private:
+  private:
     const T *ptr_;
     int i_;
     int64_t n_;
@@ -101,8 +100,8 @@ private:
 /// dimension
 /// in (4,20,2) is 2 ,
 /// (20,1) move 1 stride , to fill(add) 2 element with the same number.
-template<typename T> class MidWiseTransformIterator {
-public:
+template <typename T> class MidWiseTransformIterator {
+  public:
     MidWiseTransformIterator(const T *ptr, int n, int post)
         : ptr_(ptr), i_(0), j_(0), n_(n), post_(post) {}
 
@@ -128,7 +127,7 @@ public:
 
     const T &operator*() { return ptr_[i_]; }
 
-private:
+  private:
     const T *ptr_;
     int64_t i_;
     int64_t j_;
@@ -136,15 +135,13 @@ private:
     int64_t post_;
 };
 
-template<typename Functor, typename T, typename OutType = T>
+template <typename Functor, typename T, typename OutType = T>
 class TransformFunctor {
-public:
-  TransformFunctor(const framework::Tensor *x,
-                   const framework::Tensor *y, framework::Tensor *z,
-                   Functor func)
-      : x_(x->data<T>()), y_(y->data<T>()),
-        z_(z->mutable_data<OutType>()), nx_(x->numel()), func_(func) {
-  }
+  public:
+    TransformFunctor(const framework::Tensor *x, const framework::Tensor *y,
+                     framework::Tensor *z, Functor func)
+        : x_(x->data<T>()), y_(y->data<T>()), z_(z->mutable_data<OutType>()),
+          nx_(x->numel()), func_(func) {}
 
     inline void Run() const {
         math::Transform trans;
@@ -154,17 +151,16 @@ public:
 
     inline void RunRowWise(int n, int pre) const {
         math::Transform trans;
-    trans(x_, x_ + nx_, RowwiseTransformIterator<T>(y_, n), z_,
-          func_);
+        trans(x_, x_ + nx_, RowwiseTransformIterator<T>(y_, n), z_, func_);
     }
 
     inline void RunMidWise(int n, int pre, int post) const {
         math::Transform trans;
-    trans(x_, x_ + nx_, MidWiseTransformIterator<T>(y_, n, post),
-          z_, func_);
+        trans(x_, x_ + nx_, MidWiseTransformIterator<T>(y_, n, post), z_,
+              func_);
     }
 
-private:
+  private:
     const T *x_;
     const T *y_;
     OutType *z_;
@@ -172,10 +168,10 @@ private:
     Functor func_;
 };
 
-template<typename Functor, typename T, typename OutType = T>
+template <typename Functor, typename T, typename OutType = T>
 void ElementwiseComputeEx(const framework::Tensor *x,
-                          const framework::Tensor *y, int axis,
-                          Functor func, framework::Tensor *z) {
+                          const framework::Tensor *y, int axis, Functor func,
+                          framework::Tensor *z) {
     TransformFunctor<Functor, T, OutType> functor(x, y, z, func);
 
     auto x_dims = x->dims();
@@ -208,4 +204,4 @@ void ElementwiseComputeEx(const framework::Tensor *x,
 }
 
 } // namespace operators
-} // namespace paddle
+} // namespace paddle_mobile

src/operators/math/im2col.cc

@@ -25,13 +25,12 @@ namespace math {
  *   [input_channels, filter_height, filter_width, output_height,
  * output_width]
  */
-template<class T> class Im2ColFunctor<ColFormat::kCFO, CPU, T> {
-public:
+template <class T> class Im2ColFunctor<ColFormat::kCFO, CPU, T> {
+  public:
     void operator()(const framework::Tensor &im,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *col) {
+                    const std::vector<int> &padding, framework::Tensor *col) {
         //    PADDLE_ENFORCE(im.dims().size() == 3);
         //    PADDLE_ENFORCE(col->dims().size() == 5);
 
@@ -64,8 +63,7 @@ public:
         //                      padding(padding_up, padding_down)
         //                      are " "inconsistent.");
 
-    int channels_col =
-        im_channels * filter_height * filter_width;
+        int channels_col = im_channels * filter_height * filter_width;
 
         const T *im_data = im.data<T>();
         T *col_data = col->data<T>();
@@ -74,20 +72,17 @@ public:
             int h_offset = (c / filter_width) % filter_height;
             int c_im = c / (filter_width * filter_height);
             for (int h = 0; h < col_height; ++h) {
-        int im_row_idx = h * stride[0] - padding[0] +
-            h_offset * dilation[0];
+                int im_row_idx =
+                    h * stride[0] - padding[0] + h_offset * dilation[0];
                 for (int w = 0; w < col_width; ++w) {
-          int im_col_idx = w * stride[1] - padding[1] +
-              w_offset * dilation[1];
-          int col_idx =
-              (c * col_height + h) * col_width + w;
+                    int im_col_idx =
+                        w * stride[1] - padding[1] + w_offset * dilation[1];
+                    int col_idx = (c * col_height + h) * col_width + w;
                     int im_idx =
-              (im_row_idx + c_im * im_height) * im_width +
-                  im_col_idx;
+                        (im_row_idx + c_im * im_height) * im_width + im_col_idx;
 
                     col_data[col_idx] =
-              (im_row_idx < 0 ||
-                  im_row_idx >= im_height ||
+                        (im_row_idx < 0 || im_row_idx >= im_height ||
                          im_col_idx < 0 || im_col_idx >= im_width)
                             ? static_cast<T>(0)
                             : im_data[im_idx];
@@ -103,13 +98,12 @@ public:
  *   [input_channels, filter_height, filter_width, output_height,
  * output_width]
  */
-template<class T> class Col2ImFunctor<ColFormat::kCFO, CPU, T> {
-public:
+template <class T> class Col2ImFunctor<ColFormat::kCFO, CPU, T> {
+  public:
     void operator()(const framework::Tensor &col,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *im) {
+                    const std::vector<int> &padding, framework::Tensor *im) {
         //    PADDLE_ENFORCE(im->dims().size() == 3);
         //    PADDLE_ENFORCE(col.dims().size() == 5);
         int im_channels = im->dims()[0];
@@ -141,8 +135,7 @@ public:
         //                      padding(padding_up, padding_down)
         //                      are " "inconsistent.");
 
-    int channels_col =
-        im_channels * filter_height * filter_width;
+        int channels_col = im_channels * filter_height * filter_width;
 
         T *im_data = im->data<T>();
         const T *col_data = col.data<T>();
@@ -152,21 +145,16 @@ public:
             int h_offset = (c / filter_width) % filter_height;
             int c_im = c / (filter_width * filter_height);
             for (int h = 0; h < col_height; ++h) {
-        int im_row_idx = h * stride[0] - padding[0] +
-            h_offset * dilation[0];
+                int im_row_idx =
+                    h * stride[0] - padding[0] + h_offset * dilation[0];
                 for (int w = 0; w < col_width; ++w) {
-          int im_col_idx = w * stride[1] - padding[1] +
-              w_offset * dilation[1];
-          if ((im_row_idx) >= 0 &&
-              (im_row_idx) < im_height &&
-              (im_col_idx) >= 0 &&
-              (im_col_idx) < im_width) {
-            im_data[(im_row_idx + c_im * im_height) *
-                im_width +
+                    int im_col_idx =
+                        w * stride[1] - padding[1] + w_offset * dilation[1];
+                    if ((im_row_idx) >= 0 && (im_row_idx) < im_height &&
+                        (im_col_idx) >= 0 && (im_col_idx) < im_width) {
+                        im_data[(im_row_idx + c_im * im_height) * im_width +
                                 im_col_idx] +=
-                col_data[(c * col_height + h) *
-                    col_width +
-                    w];
+                            col_data[(c * col_height + h) * col_width + w];
                     }
                 }
             }
@@ -185,13 +173,12 @@ template class Col2ImFunctor<ColFormat::kCFO, CPU, double>;
  *   [output_height, output_width, input_channels, filter_height,
  * filter_width]
  */
-template<class T> class Im2ColFunctor<ColFormat::kOCF, CPU, T> {
-public:
+template <class T> class Im2ColFunctor<ColFormat::kOCF, CPU, T> {
+  public:
     void operator()(const framework::Tensor &im,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *col) {
+                    const std::vector<int> &padding, framework::Tensor *col) {
         //    PADDLE_ENFORCE(im.dims().size() == 3);
         //    PADDLE_ENFORCE(col->dims().size() == 5);
         int im_channels = im.dims()[0];
@@ -218,28 +205,20 @@ public:
         const T *im_data = im.data<T>();
         T *col_data = col->data<T>();
 
-    for (int col_row_idx = 0; col_row_idx < col_height;
-         ++col_row_idx) {
-      for (int col_col_idx = 0; col_col_idx < col_width;
-           ++col_col_idx) {
-        for (int channel = 0; channel < im_channels;
-             ++channel) {
-          for (int filter_row_idx = 0;
-               filter_row_idx < filter_height;
+        for (int col_row_idx = 0; col_row_idx < col_height; ++col_row_idx) {
+            for (int col_col_idx = 0; col_col_idx < col_width; ++col_col_idx) {
+                for (int channel = 0; channel < im_channels; ++channel) {
+                    for (int filter_row_idx = 0; filter_row_idx < filter_height;
                          ++filter_row_idx) {
-            int im_row_offset =
-                col_row_idx * stride[0] +
+                        int im_row_offset = col_row_idx * stride[0] +
                                             filter_row_idx - padding[0];
                         for (int filter_col_idx = 0;
-                 filter_col_idx < filter_width;
-                 ++filter_col_idx) {
-              int im_col_offset =
-                  col_col_idx * stride[1] +
+                             filter_col_idx < filter_width; ++filter_col_idx) {
+                            int im_col_offset = col_col_idx * stride[1] +
                                                 filter_col_idx - padding[1];
 
                             int col_offset =
-                  ((((col_row_idx) * col_width +
-                      col_col_idx) *
+                                ((((col_row_idx)*col_width + col_col_idx) *
                                       im_channels +
                                   channel) *
                                      filter_height +
@@ -247,15 +226,14 @@ public:
                                     filter_width +
                                 filter_col_idx;
 
-              int im_offset = (channel * im_height +
-                  im_row_offset) *
+                            int im_offset =
+                                (channel * im_height + im_row_offset) *
                                     im_width +
                                 im_col_offset;
                             col_data[col_offset] =
                                 (im_row_offset < 0 ||
                                  im_row_offset >= im_height ||
-                      im_col_offset < 0 ||
-                      im_col_offset >= im_width)
+                                 im_col_offset < 0 || im_col_offset >= im_width)
                                     ? static_cast<T>(0)
                                     : im_data[im_offset];
                         }
@@ -272,13 +250,12 @@ public:
  *   [output_height, output_width, input_channels, filter_height,
  * filter_width]
  */
-template<class T> class Col2ImFunctor<ColFormat::kOCF, CPU, T> {
-public:
+template <class T> class Col2ImFunctor<ColFormat::kOCF, CPU, T> {
+  public:
     void operator()(const framework::Tensor &col,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *im) {
+                    const std::vector<int> &padding, framework::Tensor *im) {
         //    PADDLE_ENFORCE(im->dims().size() == 3);
         //    PADDLE_ENFORCE(col.dims().size() == 5);
         int im_channels = im->dims()[0];
@@ -305,28 +282,20 @@ public:
         T *im_data = im->data<T>();
         const T *col_data = col.data<T>();
 
-    for (int col_row_idx = 0; col_row_idx < col_height;
-         ++col_row_idx) {
-      for (int col_col_idx = 0; col_col_idx < col_width;
-           ++col_col_idx) {
-        for (int channel = 0; channel < im_channels;
-             ++channel) {
-          for (int filter_row_idx = 0;
-               filter_row_idx < filter_height;
+        for (int col_row_idx = 0; col_row_idx < col_height; ++col_row_idx) {
+            for (int col_col_idx = 0; col_col_idx < col_width; ++col_col_idx) {
+                for (int channel = 0; channel < im_channels; ++channel) {
+                    for (int filter_row_idx = 0; filter_row_idx < filter_height;
                          ++filter_row_idx) {
-            int im_row_offset =
-                col_row_idx * stride[0] +
+                        int im_row_offset = col_row_idx * stride[0] +
                                             filter_row_idx - padding[0];
                         for (int filter_col_idx = 0;
-                 filter_col_idx < filter_width;
-                 ++filter_col_idx) {
-              int im_col_offset =
-                  col_col_idx * stride[1] +
+                             filter_col_idx < filter_width; ++filter_col_idx) {
+                            int im_col_offset = col_col_idx * stride[1] +
                                                 filter_col_idx - padding[1];
 
                             int col_offset =
-                  (((col_row_idx * col_width +
-                      col_col_idx) *
+                                (((col_row_idx * col_width + col_col_idx) *
                                       im_channels +
                                   channel) *
                                      filter_height +
@@ -339,12 +308,10 @@ public:
                                 im_col_offset >= 0 &&
                                 im_col_offset < im_width) {
                                 int im_offset =
-                    (channel * im_height +
-                        im_row_offset) *
+                                    (channel * im_height + im_row_offset) *
                                         im_width +
                                     im_col_offset;
-                im_data[im_offset] +=
-                    col_data[col_offset];
+                                im_data[im_offset] += col_data[col_offset];
                             }
                         }
                     }

src/operators/math/im2col.h

@@ -87,24 +87,22 @@ enum class ColFormat { kCFO = 0, kOCF = 1 };
  * equal to
  *       colShape.inputChannels.
  */
-template<ColFormat Format, typename DeviceType, typename T>
+template <ColFormat Format, typename DeviceType, typename T>
 class Im2ColFunctor {
-public:
+  public:
     void operator()(const framework::Tensor &im,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *col);
+                    const std::vector<int> &padding, framework::Tensor *col);
 };
 
-template<ColFormat Format, typename DeviceType, typename T>
+template <ColFormat Format, typename DeviceType, typename T>
 class Col2ImFunctor {
-public:
+  public:
     void operator()(const framework::Tensor &col,
                     const std::vector<int> &dilation,
                     const std::vector<int> &stride,
-                  const std::vector<int> &padding,
-                  framework::Tensor *im);
+                    const std::vector<int> &padding, framework::Tensor *im);
 };
 
 } // namespace math

src/operators/math/math_function.cc

@@ -18,61 +18,53 @@ namespace paddle_mobile {
 namespace operators {
 namespace math {
 
-template<>
-void gemm<float>(const CBLAS_TRANSPOSE transA,
-                 const CBLAS_TRANSPOSE transB, const int M,
-                 const int N, const int K, const float alpha,
-                 const float *A, const float *B, const float beta,
-                 float *C) {
+template <>
+void gemm<float>(const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB,
+                 const int M, const int N, const int K, const float alpha,
+                 const float *A, const float *B, const float beta, float *C) {
     int lda = (transA == CblasNoTrans) ? K : M;
     int ldb = (transB == CblasNoTrans) ? N : K;
     int ldc = N;
-  cblas_sgemm(CblasRowMajor, transA, transB, M, N, K, alpha, A,
-              lda, B, ldb, beta, C, ldc);
+    cblas_sgemm(CblasRowMajor, transA, transB, M, N, K, alpha, A, lda, B, ldb,
+                beta, C, ldc);
 }
 
-template<>
-void gemm<double>(const CBLAS_TRANSPOSE transA,
-                  const CBLAS_TRANSPOSE transB, const int M,
-                  const int N, const int K, const double alpha,
-                  const double *A, const double *B,
-                  const double beta, double *C) {
+template <>
+void gemm<double>(const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB,
+                  const int M, const int N, const int K, const double alpha,
+                  const double *A, const double *B, const double beta,
+                  double *C) {
     int lda = (transA == CblasNoTrans) ? K : M;
     int ldb = (transB == CblasNoTrans) ? N : K;
     int ldc = N;
-  cblas_dgemm(CblasRowMajor, transA, transB, M, N, K, alpha, A,
-              lda, B, ldb, beta, C, ldc);
+    cblas_dgemm(CblasRowMajor, transA, transB, M, N, K, alpha, A, lda, B, ldb,
+                beta, C, ldc);
 }
 
-template<>
-void gemm<float>(const bool transA, const bool transB, const int M,
-                 const int N, const int K, const float alpha,
-                 const float *A, const int lda, const float *B,
-                 const int ldb, const float beta, float *C,
+template <>
+void gemm<float>(const bool transA, const bool transB, const int M, const int N,
+                 const int K, const float alpha, const float *A, const int lda,
+                 const float *B, const int ldb, const float beta, float *C,
                  const int ldc) {
-  cblas_sgemm(CblasRowMajor,
-              transA == false ? CblasNoTrans : CblasTrans,
-              transB == false ? CblasNoTrans : CblasTrans, M, N,
-              K, alpha, A, lda, B, ldb, beta, C, ldc);
+    cblas_sgemm(CblasRowMajor, transA == false ? CblasNoTrans : CblasTrans,
+                transB == false ? CblasNoTrans : CblasTrans, M, N, K, alpha, A,
+                lda, B, ldb, beta, C, ldc);
 }
 
-template<>
+template <>
 void gemm<double>(const bool transA, const bool transB, const int M,
-                  const int N, const int K, const double alpha,
-                  const double *A, const int lda, const double *B,
-                  const int ldb, const double beta, double *C,
-                  const int ldc) {
-  cblas_dgemm(CblasRowMajor,
-              transA == false ? CblasNoTrans : CblasTrans,
-              transB == false ? CblasNoTrans : CblasTrans, M, N,
-              K, alpha, A, lda, B, ldb, beta, C, ldc);
+                  const int N, const int K, const double alpha, const double *A,
+                  const int lda, const double *B, const int ldb,
+                  const double beta, double *C, const int ldc) {
+    cblas_dgemm(CblasRowMajor, transA == false ? CblasNoTrans : CblasTrans,
+                transB == false ? CblasNoTrans : CblasTrans, M, N, K, alpha, A,
+                lda, B, ldb, beta, C, ldc);
 }
 
-template<>
+template <>
 void matmul<float>(const framework::Tensor &matrix_a, bool trans_a,
-                   const framework::Tensor &matrix_b, bool trans_b,
-                   float alpha, framework::Tensor *matrix_out,
-                   float beta) {
+                   const framework::Tensor &matrix_b, bool trans_b, float alpha,
+                   framework::Tensor *matrix_out, float beta) {
     auto dim_a = matrix_a.dims();
     auto dim_b = matrix_b.dims();
     auto dim_out = matrix_out->dims();
@@ -91,21 +83,17 @@ void matmul<float>(const framework::Tensor &matrix_a, bool trans_a,
     int N = dim_out[1];
     int K = (trans_a == false) ? dim_a[1] : dim_a[0];
 
-  CBLAS_TRANSPOSE transA =
-      (trans_a == false) ? CblasNoTrans : CblasTrans;
-  CBLAS_TRANSPOSE transB =
-      (trans_b == false) ? CblasNoTrans : CblasTrans;
+    CBLAS_TRANSPOSE transA = (trans_a == false) ? CblasNoTrans : CblasTrans;
+    CBLAS_TRANSPOSE transB = (trans_b == false) ? CblasNoTrans : CblasTrans;
 
-  gemm<float>(transA, transB, M, N, K, alpha,
-              matrix_a.data<float>(), matrix_b.data<float>(),
-              beta, matrix_out->data<float>());
+    gemm<float>(transA, transB, M, N, K, alpha, matrix_a.data<float>(),
+                matrix_b.data<float>(), beta, matrix_out->data<float>());
 }
 
-template<>
+template <>
 void matmul<double>(const framework::Tensor &matrix_a, bool trans_a,
                     const framework::Tensor &matrix_b, bool trans_b,
-                    double alpha, framework::Tensor *matrix_out,
-                    double beta) {
+                    double alpha, framework::Tensor *matrix_out, double beta) {
     auto dim_a = matrix_a.dims();
     auto dim_b = matrix_b.dims();
     auto dim_out = matrix_out->dims();
@@ -124,14 +112,11 @@ void matmul<double>(const framework::Tensor &matrix_a, bool trans_a,
     int N = dim_out[1];
     int K = (trans_a == false) ? dim_a[1] : dim_a[0];
 
-  CBLAS_TRANSPOSE transA =
-      (trans_a == false) ? CblasNoTrans : CblasTrans;
-  CBLAS_TRANSPOSE transB =
-      (trans_b == false) ? CblasNoTrans : CblasTrans;
+    CBLAS_TRANSPOSE transA = (trans_a == false) ? CblasNoTrans : CblasTrans;
+    CBLAS_TRANSPOSE transB = (trans_b == false) ? CblasNoTrans : CblasTrans;
 
-  gemm<double>(transA, transB, M, N, K, alpha,
-               matrix_a.data<double>(), matrix_b.data<double>(),
-               beta, matrix_out->data<double>());
+    gemm<double>(transA, transB, M, N, K, alpha, matrix_a.data<double>(),
+                 matrix_b.data<double>(), beta, matrix_out->data<double>());
 }
 
 } // namespace math

src/operators/math/math_function.h

@@ -22,23 +22,21 @@ namespace paddle_mobile {
 namespace operators {
 namespace math {
 
-template<typename T>
-void gemm(const CBLAS_TRANSPOSE transA,
-          const CBLAS_TRANSPOSE transB, const int M, const int N,
-          const int K, const T alpha, const T *A, const T *B,
-          const T beta, T *C);
-
-template<typename T>
-void gemm(const bool transA, const bool transB, const int M,
-          const int N, const int K, const T alpha, const T *A,
-          const int lda, const T *B, const int ldb, const T beta,
-          T *C, const int ldc);
+template <typename T>
+void gemm(const CBLAS_TRANSPOSE transA, const CBLAS_TRANSPOSE transB,
+          const int M, const int N, const int K, const T alpha, const T *A,
+          const T *B, const T beta, T *C);
+
+template <typename T>
+void gemm(const bool transA, const bool transB, const int M, const int N,
+          const int K, const T alpha, const T *A, const int lda, const T *B,
+          const int ldb, const T beta, T *C, const int ldc);
 
 // matrix multiply with continuous memory
-template<typename T>
+template <typename T>
 void matmul(const framework::Tensor &matrix_a, bool trans_a,
-            const framework::Tensor &matrix_b, bool trans_b,
-            T alpha, framework::Tensor *matrix_out, T beta);
+            const framework::Tensor &matrix_b, bool trans_b, T alpha,
+            framework::Tensor *matrix_out, T beta);
 } // namespace math
 } // namespace operators
 } // namespace paddle_mobile

src/operators/math/transform.h

@@ -37,21 +37,19 @@ namespace math {
 //       class, paddle::fluid::operators::RowwiseTRansformIterator.
 
 struct Transform {
-  template<typename InputIter, typename OutputIter,
-      typename UnaryOperation>
-  void operator()(InputIter first, InputIter last,
-                  OutputIter result, UnaryOperation op) {
+    template <typename InputIter, typename OutputIter, typename UnaryOperation>
+    void operator()(InputIter first, InputIter last, OutputIter result,
+                    UnaryOperation op) {
         std::transform(first, last, result, op);
     }
 
-  template<typename InputIter1, typename InputIter2,
-      typename OutputIter, typename BinaryOperation>
-  void operator()(InputIter1 first1, InputIter1 last1,
-                  InputIter2 first2, OutputIter result,
-                  BinaryOperation op) {
+    template <typename InputIter1, typename InputIter2, typename OutputIter,
+              typename BinaryOperation>
+    void operator()(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+                    OutputIter result, BinaryOperation op) {
         std::transform(first1, last1, first2, result, op);
     }
 };
-}
-} // namespace platform
-} // namespace paddle
+} // namespace math
+} // namespace operators
+} // namespace paddle_mobile

src/operators/math/vol2col.cc

@@ -25,13 +25,11 @@ using Tensor = paddle_mobile::framework::Tensor;
  *   [input_channels, filter_depth, filter_height, filter_width,
  *                    output_depth, output_height, output_width]
  */
-template<typename T> class Vol2ColFunctor<CPU, T> {
-public:
-  void operator()(const Tensor &vol,
-                  const std::vector<int> &dilations,
+template <typename T> class Vol2ColFunctor<CPU, T> {
+  public:
+    void operator()(const Tensor &vol, const std::vector<int> &dilations,
                     const std::vector<int> &strides,
-                  const std::vector<int> &paddings,
-                  Tensor *col) const {
+                    const std::vector<int> &paddings, Tensor *col) const {
         //    PADDLE_ENFORCE(vol.dims().size() == 4);
         //    PADDLE_ENFORCE(col->dims().size() == 7);
 
@@ -45,8 +43,8 @@ public:
         int output_depth = col->dims()[4];
         int output_height = col->dims()[5];
         int output_width = col->dims()[6];
-    int channels_col = input_channels * filter_depth *
-        filter_height * filter_width;
+        int channels_col =
+            input_channels * filter_depth * filter_height * filter_width;
 
         //    PADDLE_ENFORCE_EQ((input_depth + 2 * paddings[0] -
         //                       ((dilations[0] * (filter_depth - 1)
@@ -80,35 +78,31 @@ public:
         for (int c = 0; c < channels_col; ++c) {
             int w_offset = c % filter_width;
             int h_offset = (c / filter_width) % filter_height;
-      int d_offset =
-          (c / filter_width / filter_height) % filter_depth;
-      int c_in =
-          c / filter_width / filter_height / filter_depth;
+            int d_offset = (c / filter_width / filter_height) % filter_depth;
+            int c_in = c / filter_width / filter_height / filter_depth;
             for (int d = 0; d < output_depth; ++d) {
-        int d_pad = d * strides[0] - paddings[0] +
-            d_offset * dilations[0];
+                int d_pad =
+                    d * strides[0] - paddings[0] + d_offset * dilations[0];
                 for (int h = 0; h < output_height; ++h) {
-          int h_pad = h * strides[1] - paddings[1] +
-              h_offset * dilations[1];
+                    int h_pad =
+                        h * strides[1] - paddings[1] + h_offset * dilations[1];
                     for (int w = 0; w < output_width; ++w) {
                         int w_pad = w * strides[2] - paddings[2] +
                                     w_offset * dilations[2];
 
-            int col_idx = ((c * output_depth + d) *
-                output_height +
-                h) *
+                        int col_idx =
+                            ((c * output_depth + d) * output_height + h) *
                                 output_width +
                             w;
                         int vol_idx =
-                ((c_in * input_depth + d_pad) *
-                    input_height +
+                            ((c_in * input_depth + d_pad) * input_height +
                              h_pad) *
                                 input_width +
                             w_pad;
                         col_data[col_idx] =
-                (h_pad < 0 || h_pad >= input_height ||
-                    w_pad < 0 || w_pad >= input_width ||
-                    d_pad < 0 || d_pad >= input_depth)
+                            (h_pad < 0 || h_pad >= input_height || w_pad < 0 ||
+                             w_pad >= input_width || d_pad < 0 ||
+                             d_pad >= input_depth)
                                 ? static_cast<T>(0)
                                 : vol_data[vol_idx];
                     }
@@ -124,13 +118,11 @@ public:
  *   [input_channels, filter_depth, filter_height, filter_width,
  *                    output_depth, output_height, output_width]
  */
-template<typename T> class Col2VolFunctor<CPU, T> {
-public:
-  void operator()(const Tensor &col,
-                  const std::vector<int> &dilations,
+template <typename T> class Col2VolFunctor<CPU, T> {
+  public:
+    void operator()(const Tensor &col, const std::vector<int> &dilations,
                     const std::vector<int> &strides,
-                  const std::vector<int> &paddings,
-                  Tensor *vol) const {
+                    const std::vector<int> &paddings, Tensor *vol) const {
         //    PADDLE_ENFORCE(vol->dims().size() == 4);
         //    PADDLE_ENFORCE(col.dims().size() == 7);
 
@@ -144,8 +136,8 @@ public:
         int output_depth = col.dims()[4];
         int output_height = col.dims()[5];
         int output_width = col.dims()[6];
-    int channels_col = input_channels * filter_depth *
-        filter_height * filter_width;
+        int channels_col =
+            input_channels * filter_depth * filter_height * filter_width;
 
         //    PADDLE_ENFORCE_EQ((input_depth + 2 * paddings[0] -
         //                       ((dilations[0] * (filter_depth - 1)
@@ -178,33 +170,29 @@ public:
         for (int c = 0; c < channels_col; ++c) {
             int w_offset = c % filter_width;
             int h_offset = (c / filter_width) % filter_height;
-      int d_offset =
-          (c / filter_width / filter_height) % filter_depth;
-      int cIm =
-          c / filter_width / filter_height / filter_depth;
+            int d_offset = (c / filter_width / filter_height) % filter_depth;
+            int cIm = c / filter_width / filter_height / filter_depth;
             for (int d = 0; d < output_depth; ++d) {
-        int d_pad = d * strides[0] - paddings[0] +
-            d_offset * dilations[0];
+                int d_pad =
+                    d * strides[0] - paddings[0] + d_offset * dilations[0];
                 for (int h = 0; h < output_height; ++h) {
-          int h_pad = h * strides[1] - paddings[1] +
-              h_offset * dilations[1];
+                    int h_pad =
+                        h * strides[1] - paddings[1] + h_offset * dilations[1];
                     for (int w = 0; w < output_width; ++w) {
                         int w_pad = w * strides[2] - paddings[2] +
                                     w_offset * dilations[2];
 
-            if (h_pad >= 0 && h_pad < input_height &&
-                w_pad >= 0 && w_pad < input_width &&
-                d_pad >= 0 && d_pad < input_depth) {
+                        if (h_pad >= 0 && h_pad < input_height && w_pad >= 0 &&
+                            w_pad < input_width && d_pad >= 0 &&
+                            d_pad < input_depth) {
                             int vol_idx =
-                  ((cIm * input_depth + d_pad) *
-                      input_height +
+                                ((cIm * input_depth + d_pad) * input_height +
                                  h_pad) *
                                     input_width +
                                 w_pad;
 
-              int col_idx = ((c * output_depth + d) *
-                  output_height +
-                  h) *
+                            int col_idx =
+                                ((c * output_depth + d) * output_height + h) *
                                     output_width +
                                 w;
                             vol_data[vol_idx] += col_data[col_idx];

src/operators/math/vol2col.h

@@ -72,22 +72,18 @@ namespace math {
  */
 using Tensor = paddle_mobile::framework::Tensor;
 
-template<typename DeviceType, typename T> class Vol2ColFunctor {
-public:
-  void operator()(const Tensor &vol,
-                  const std::vector<int> &dilations,
+template <typename DeviceType, typename T> class Vol2ColFunctor {
+  public:
+    void operator()(const Tensor &vol, const std::vector<int> &dilations,
                     const std::vector<int> &strides,
-                  const std::vector<int> &paddings,
-                  Tensor *col) const;
+                    const std::vector<int> &paddings, Tensor *col) const;
 };
 
-template<typename DeviceType, typename T> class Col2VolFunctor {
-public:
-  void operator()(const Tensor &col,
-                  const std::vector<int> &dilations,
+template <typename DeviceType, typename T> class Col2VolFunctor {
+  public:
+    void operator()(const Tensor &col, const std::vector<int> &dilations,
                     const std::vector<int> &strides,
-                  const std::vector<int> &paddings,
-                  Tensor *vol) const;
+                    const std::vector<int> &paddings, Tensor *vol) const;
 };
 
 } // namespace math

src/operators/mul_op.cpp

@@ -21,8 +21,7 @@ SOFTWARE.
 namespace paddle_mobile {
 namespace operators {
 
-template<typename Dtype, typename T>
-void MulOp<Dtype, T>::InferShape() const {
+template <typename Dtype, typename T> void MulOp<Dtype, T>::InferShape() const {
     auto x_dims = param_.InputX()->dims();
     auto y_dims = param_.InputY()->dims();
     int x_num_col_dims = param_.XNumColDims();
@@ -38,8 +37,8 @@ void MulOp<Dtype, T>::InferShape() const {
     assert(x_mat_dims[1] == y_mat_dims[0]);
 
     std::vector<int64_t> output_dims;
-  output_dims.reserve(static_cast<size_t>(
-                          x_num_col_dims + y_dims.size() - y_num_col_dims));
+    output_dims.reserve(
+        static_cast<size_t>(x_num_col_dims + y_dims.size() - y_num_col_dims));
 
     for (int i = 0; i < x_num_col_dims; ++i) {
         output_dims.push_back(x_dims[i]);
@@ -53,5 +52,5 @@ void MulOp<Dtype, T>::InferShape() const {
     param_.Out()->Resize(ddim);
 }
 template class MulOp<CPU, float>;
-}
-}
+} // namespace operators
+} // namespace paddle_mobile

src/operators/mul_op.h

@@ -25,15 +25,14 @@ namespace operators {
 
 using namespace framework;
 
-template<typename DeviceType, typename T>
+template <typename DeviceType, typename T>
 class MulOp : public framework::OperatorWithKernel<DeviceType> {
-public:
+  public:
     MulOp(const std::string &type, const VariableNameMap &inputs,
-        const VariableNameMap &outputs,
-        const framework::AttributeMap attrs,
+          const VariableNameMap &outputs, const framework::AttributeMap attrs,
           std::shared_ptr<framework::Scope> scope)
-      : framework::OperatorWithKernel<DeviceType>(
-      type, inputs, outputs, attrs, scope),
+        : framework::OperatorWithKernel<DeviceType>(type, inputs, outputs,
+                                                    attrs, scope),
           param_(inputs, outputs, attrs, *scope) {}
 
     void Run() const {
@@ -44,9 +43,9 @@ public:
     using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
     void InferShape() const override;
 
-protected:
+  protected:
     MulParam param_;
 };
 
 } // namespace operators
-} // namespace paddle
+} // namespace paddle_mobile

src/operators/op_param.cpp

@@ -24,16 +24,16 @@ Print &operator<<(Print &printer, const ConvParam &conv_param) {
     printer << "parameter of conv: "
             << "\n";
     printer << "  stride: "
-          << " (" << conv_param.Strides()[0]
-          << conv_param.Strides()[1] << ") "
+            << " (" << conv_param.Strides()[0] << conv_param.Strides()[1]
+            << ") "
             << "\n";
     printer << "  paddings: "
-          << " (" << conv_param.Paddings()[0]
-          << conv_param.Paddings()[1] << ") "
+            << " (" << conv_param.Paddings()[0] << conv_param.Paddings()[1]
+            << ") "
             << "\n";
     printer << "  dilations: "
-          << " (" << conv_param.Dilations()[0]
-          << conv_param.Dilations()[1] << ") "
+            << " (" << conv_param.Dilations()[0] << conv_param.Dilations()[1]
+            << ") "
             << "\n";
     printer << "  groups: " << conv_param.Groups() << "\n";
     printer << "  input  dims: " << conv_param.Input()->dims() << "\n";

src/operators/op_param.h

@@ -31,58 +31,51 @@ namespace operators {
 using namespace framework;
 
 class OpParam : PaddleMobileObject {
-public:
-protected:
-  template<typename T>
-  static T *InputFrom(const VariableNameMap &inputs,
-                      const Scope &scope) {
+  public:
+  protected:
+    template <typename T>
+    static T *InputFrom(const VariableNameMap &inputs, const Scope &scope) {
         return GetVarValue<T>("Input", inputs, scope);
     }
 
-  template<typename T>
-  static T *InputXFrom(const VariableNameMap &inputs,
-                       const Scope &scope) {
+    template <typename T>
+    static T *InputXFrom(const VariableNameMap &inputs, const Scope &scope) {
         return GetVarValue<T>("X", inputs, scope);
     }
 
-  template<typename T>
-  static T *InputYFrom(const VariableNameMap &inputs,
-                       const Scope &scope) {
+    template <typename T>
+    static T *InputYFrom(const VariableNameMap &inputs, const Scope &scope) {
         return GetVarValue<T>("Y", inputs, scope);
     }
 
-  template<typename T>
-  static std::vector<T *>
-  InputMultiFrom(const VariableNameMap &inputs, const Scope &scope) {
+    template <typename T>
+    static std::vector<T *> InputMultiFrom(const VariableNameMap &inputs,
+                                           const Scope &scope) {
         return GetMultiVarValue<T>("Input", inputs, scope);
     }
 
-  template<typename T>
-  static T *OutputFrom(const VariableNameMap &outputs,
-                       const Scope &scope) {
+    template <typename T>
+    static T *OutputFrom(const VariableNameMap &outputs, const Scope &scope) {
         return GetVarValue<T>("Output", outputs, scope);
     }
 
-  template<typename T>
-  static T *OutFrom(const VariableNameMap &outputs,
-                    const Scope &scope) {
+    template <typename T>
+    static T *OutFrom(const VariableNameMap &outputs, const Scope &scope) {
         return GetVarValue<T>("Out", outputs, scope);
     }
 
-  template<typename T>
-  static T *FilterFrom(const VariableNameMap &inputs,
-                       const Scope &scope) {
+    template <typename T>
+    static T *FilterFrom(const VariableNameMap &inputs, const Scope &scope) {
         return GetVarValue<T>("Filter", inputs, scope);
     }
 
-  template<typename T>
+    template <typename T>
     static const T GetAttr(std::string key, const AttributeMap &map) {
-    return ((Attribute) map.at(key)).Get<T>();
+        return ((Attribute)map.at(key)).Get<T>();
     }
 
-  template<typename T>
-  static T *GetVarValue(std::string key,
-                        const VariableNameMap &var_map,
+    template <typename T>
+    static T *GetVarValue(std::string key, const VariableNameMap &var_map,
                           const Scope &scope) {
         auto var_vec = var_map.at(key);
         if (var_vec.size()) {
@@ -95,9 +88,9 @@ protected:
         }
     }
 
-  template<typename T>
-  static std::vector<T *>
-  GetMultiVarValue(std::string key, const VariableNameMap &var_map,
+    template <typename T>
+    static std::vector<T *> GetMultiVarValue(std::string key,
+                                             const VariableNameMap &var_map,
                                              const Scope &scope) {
         auto var_vecs = var_map.at(key);
         assert(var_vecs.size() > 1);
@@ -111,9 +104,8 @@ protected:
 };
 
 class ConvParam : OpParam {
-public:
-  ConvParam(const VariableNameMap &inputs,
-            const VariableNameMap &outputs,
+  public:
+    ConvParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const framework::AttributeMap &attrs,
               const framework::Scope &scope) {
         filter_ = FilterFrom<framework::LoDTensor>(inputs, scope);
@@ -139,7 +131,7 @@ public:
 
     const int &Groups() const { return groups; }
 
-private:
+  private:
     Tensor *input_;
     Tensor *output_;
     LoDTensor *filter_;
@@ -152,7 +144,7 @@ private:
 Print &operator<<(Print &printer, const ConvParam &conv_param);
 
 class ElementwiseAddParam : OpParam {
-public:
+  public:
     ElementwiseAddParam(const VariableNameMap &inputs,
                         const VariableNameMap &outputs,
                         const framework::AttributeMap &attrs,
@@ -171,7 +163,7 @@ public:
 
     const int &Axis() const { return axis_; }
 
-private:
+  private:
     Tensor *input_x_;
     Tensor *input_y_;
     Tensor *out_;
@@ -179,9 +171,8 @@ private:
 };
 
 class MulParam : OpParam {
-public:
-  MulParam(const VariableNameMap &inputs,
-           const VariableNameMap &outputs,
+  public:
+    MulParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
              const framework::AttributeMap &attrs,
              const framework::Scope &scope) {
         input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
@@ -201,7 +192,7 @@ public:
 
     const int &YNumColDims() const { return y_num_col_dims_; }
 
-private:
+  private:
     Tensor *input_x_;
     Tensor *input_y_;
     Tensor *out_;
@@ -210,9 +201,8 @@ private:
 };
 
 class ConcatParam : public OpParam {
-public:
-  ConcatParam(const VariableNameMap &inputs,
-              const VariableNameMap &outputs,
+  public:
+    ConcatParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const framework::AttributeMap &attrs,
                 const framework::Scope &scope) {
         inputs_ = InputMultiFrom<framework::Tensor>(inputs, scope);
@@ -226,7 +216,7 @@ public:
 
     const int &Axis() const { return axis_; }
 
-private:
+  private:
     std::vector<Tensor *> inputs_;
     Tensor *out_;
     int axis_;

test/common/test_log.cpp

@@ -22,9 +22,10 @@ int main() {
 
     DLOGF("DASJFDAFJ%d -- %f", 12345, 344.234);
 
-    LOGF( paddle_mobile::kLOG_DEBUG, "DASJFDAFJ%d -- %f", 12345, 344.234);
+    LOGF(paddle_mobile::kLOG_DEBUG, "DASJFDAFJ%d -- %f", 12345, 344.234);
 
-    LOG(paddle_mobile::kLOG_DEBUG) << "test debug" << " next log";
+    LOG(paddle_mobile::kLOG_DEBUG) << "test debug"
+                                   << " next log";
 
     LOG(paddle_mobile::kLOG_DEBUG1) << "test debug1"
                                     << " next log";

test/elementwise_add_op_test.h

@@ -21,9 +21,9 @@ SOFTWARE.
 #include "test_include.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype> class TestElementwiseAddOp {
+template <typename Dtype> class TestElementwiseAddOp {
   public:
     TestElementwiseAddOp(const Program<Dtype> p) : program_(p) {
         if (use_optimize_) {
@@ -37,8 +37,7 @@ namespace paddle_mobile {
         //  DLOG << " **block size " << blocks.size();
         for (int i = 0; i < blocks.size(); ++i) {
             std::shared_ptr<BlockDesc> block_desc = blocks[i];
-                    std::vector<std::shared_ptr<OpDesc>> ops =
-                        block_desc->Ops();
+            std::vector<std::shared_ptr<OpDesc>> ops = block_desc->Ops();
             //    DLOG << " ops " << ops.size();
             for (int j = 0; j < ops.size(); ++j) {
                 std::shared_ptr<OpDesc> op = ops[j];
@@ -59,8 +58,7 @@ namespace paddle_mobile {
                     DLOG << " elementwise_add attr size: "
                          << op->GetAttrMap().size();
                     DLOG << " inputs size: " << op->GetInputs().size();
-                            DLOG << " outputs size: "
-                                 << op->GetOutputs().size();
+                    DLOG << " outputs size: " << op->GetOutputs().size();
                     DLOG << " Input X is : " << op->Input("X")[0];
                     DLOG << " Input Y is : " << op->Input("Y")[0];
                     DLOG << " Output Out is : " << op->Output("Out")[0];
@@ -68,13 +66,11 @@ namespace paddle_mobile {
                     int axis = axis_attr.Get<int>();
                     DLOG << " Attr axis is : " << axis;
 
-                            std::shared_ptr<
-                                operators::ElementwiseAddOp<Dtype, float>>
+                    std::shared_ptr<operators::ElementwiseAddOp<Dtype, float>>
                         add = std::make_shared<
                             operators::ElementwiseAddOp<Dtype, float>>(
-                                    op->Type(), op->GetInputs(),
-                                    op->GetOutputs(), op->GetAttrMap(),
-                                    program_.scope);
+                            op->Type(), op->GetInputs(), op->GetOutputs(),
+                            op->GetAttrMap(), program_.scope);
                     ops_of_block_[*block_desc.get()].push_back(add);
                 }
             }
@@ -98,8 +94,7 @@ namespace paddle_mobile {
         //  DLOG << typeid(output_tensor).name();
         //  DLOG << "output_tensor dims: " << output_tensor->dims();
 
-                std::shared_ptr<Tensor> out_tensor =
-                    std::make_shared<LoDTensor>();
+        std::shared_ptr<Tensor> out_tensor = std::make_shared<LoDTensor>();
         out_tensor.reset(output_tensor);
 
         predict_add(t1, t2, 0);
@@ -117,25 +112,25 @@ namespace paddle_mobile {
     void predict_add(const Tensor &t1, const Tensor &t2, int block_id) {
         std::shared_ptr<BlockDesc> to_predict_block =
             to_predict_program_->Block(block_id);
-                for (int j = 0;
-                     j < ops_of_block_[*to_predict_block.get()].size(); ++j) {
+        for (int j = 0; j < ops_of_block_[*to_predict_block.get()].size();
+             ++j) {
             auto op = ops_of_block_[*to_predict_block.get()][j];
             DLOG << "op -> run()";
             op->Run();
         }
     }
-        };
+};
 
-        template class TestElementwiseAddOp<CPU>;
-    } // namespace framework
+template class TestElementwiseAddOp<CPU>;
+} // namespace framework
 
-    namespace test {
-        void testElementwiseAdd() {
+namespace test {
+void testElementwiseAdd() {
     DLOG << "----------**********----------";
     DLOG << "begin to run ElementAddOp Test";
     paddle_mobile::Loader<paddle_mobile::CPU> loader;
-            auto program = loader.Load(
-                std::string("../../test/models/"
+    auto program =
+        loader.Load(std::string("../../test/models/"
                                 "image_classification_resnet.inference.model"));
 
     /// input x (1,3,224,224)
@@ -164,6 +159,6 @@ namespace paddle_mobile {
 
     DLOG << inputx_ptr[226] << " + " << inputy_ptr[2] << " = "
          << output_add_ptr[226];
-        }
-    } // namespace test
+}
+} // namespace test
 } // namespace paddle_mobile

test/mul_op_test.h

@@ -21,9 +21,9 @@ SOFTWARE.
 #include "test_include.h"
 
 namespace paddle_mobile {
-    namespace framework {
+namespace framework {
 
-        template <typename Dtype> class TestMulOp {
+template <typename Dtype> class TestMulOp {
   public:
     TestMulOp(const Program<Dtype> p) : program_(p) {
         if (use_optimize_) {
@@ -37,8 +37,7 @@ namespace paddle_mobile {
         //  DLOG << " **block size " << blocks.size();
         for (int i = 0; i < blocks.size(); ++i) {
             std::shared_ptr<BlockDesc> block_desc = blocks[i];
-                    std::vector<std::shared_ptr<OpDesc>> ops =
-                        block_desc->Ops();
+            std::vector<std::shared_ptr<OpDesc>> ops = block_desc->Ops();
             //    DLOG << " ops " << ops.size();
             for (int j = 0; j < ops.size(); ++j) {
                 std::shared_ptr<OpDesc> op = ops[j];
@@ -59,29 +58,21 @@ namespace paddle_mobile {
                 //                        DLOG << "op:" << op->Type();
                 if (op->Type() == "mul" &&
                     op->Input("X")[0] == "pool2d_0.tmp_0") {
-                            DLOG << " mul attr size: "
-                                 << op->GetAttrMap().size();
+                    DLOG << " mul attr size: " << op->GetAttrMap().size();
                     DLOG << " inputs size: " << op->GetInputs().size();
-                            DLOG << " outputs size: "
-                                 << op->GetOutputs().size();
+                    DLOG << " outputs size: " << op->GetOutputs().size();
                     DLOG << " Input X is : " << op->Input("X")[0];
                     DLOG << " Input Y is : " << op->Input("Y")[0];
                     DLOG << " Output Out is : " << op->Output("Out")[0];
                     DLOG << "x_num_col_dims : "
-                                 << op->GetAttrMap()
-                                        .at("x_num_col_dims")
-                                        .Get<int>();
+                         << op->GetAttrMap().at("x_num_col_dims").Get<int>();
                     DLOG << "y_num_col_dims : "
-                                 << op->GetAttrMap()
-                                        .at("y_num_col_dims")
-                                        .Get<int>();
-
-                            std::shared_ptr<operators::MulOp<Dtype, float>>
-                                add = std::make_shared<
-                                    operators::MulOp<Dtype, float>>(
-                                    op->Type(), op->GetInputs(),
-                                    op->GetOutputs(), op->GetAttrMap(),
-                                    program_.scope);
+                         << op->GetAttrMap().at("y_num_col_dims").Get<int>();
+
+                    std::shared_ptr<operators::MulOp<Dtype, float>> add =
+                        std::make_shared<operators::MulOp<Dtype, float>>(
+                            op->Type(), op->GetInputs(), op->GetOutputs(),
+                            op->GetAttrMap(), program_.scope);
                     ops_of_block_[*block_desc.get()].push_back(add);
                 }
             }
@@ -105,8 +96,7 @@ namespace paddle_mobile {
         //  DLOG << typeid(output_tensor).name();
         //  DLOG << "output_tensor dims: " << output_tensor->dims();
 
-                std::shared_ptr<Tensor> out_tensor =
-                    std::make_shared<LoDTensor>();
+        std::shared_ptr<Tensor> out_tensor = std::make_shared<LoDTensor>();
         out_tensor.reset(output_tensor);
 
         predict_add(t1, t2, 0);
@@ -124,25 +114,25 @@ namespace paddle_mobile {
     void predict_add(const Tensor &t1, const Tensor &t2, int block_id) {
         std::shared_ptr<BlockDesc> to_predict_block =
             to_predict_program_->Block(block_id);
-                for (int j = 0;
-                     j < ops_of_block_[*to_predict_block.get()].size(); ++j) {
+        for (int j = 0; j < ops_of_block_[*to_predict_block.get()].size();
+             ++j) {
             auto op = ops_of_block_[*to_predict_block.get()][j];
             DLOG << "op -> run()";
             op->Run();
         }
     }
-        };
+};
 
-        template class TestMulOp<CPU>;
-    } // namespace framework
+template class TestMulOp<CPU>;
+} // namespace framework
 
-    namespace test {
-        void testMul() {
+namespace test {
+void testMul() {
     DLOG << "----------**********----------";
     DLOG << "begin to run MulOp Test";
     paddle_mobile::Loader<paddle_mobile::CPU> loader;
-            auto program = loader.Load(
-                std::string("../../test/models/"
+    auto program =
+        loader.Load(std::string("../../test/models/"
                                 "image_classification_resnet.inference.model"));
 
     /// input x (3,2,1,1)
@@ -157,8 +147,7 @@ namespace paddle_mobile {
                        static_cast<float>(1));
     float *inputy_ptr = inputy.data<float>();
 
-            paddle_mobile::framework::TestMulOp<paddle_mobile::CPU> testMulOp(
-                program);
+    paddle_mobile::framework::TestMulOp<paddle_mobile::CPU> testMulOp(program);
 
     auto output_mul = testMulOp.predict_add(inputx, inputy);
     float *output_mul_ptr = output_mul->data<float>();
@@ -194,9 +183,8 @@ namespace paddle_mobile {
     DLOG << "output memory size : " << output_mul->memory_size();
     DLOG << "output numel : " << output_mul->numel();
 
-            DLOG << inputx_ptr[0] << " x " << inputy_ptr[0] << " + "
-                 << inputx_ptr[1] << " x " << inputy_ptr[0 + 3] << " = "
-                 << output_mul_ptr[0];
-        }
-    } // namespace test
+    DLOG << inputx_ptr[0] << " x " << inputy_ptr[0] << " + " << inputx_ptr[1]
+         << " x " << inputy_ptr[0 + 3] << " = " << output_mul_ptr[0];
+}
+} // namespace test
 } // namespace paddle_mobile

test/test_include.h

@@ -7,7 +7,6 @@
 #include "framework/scope.h"
 #include "framework/tensor.h"
 #include "framework/variable.h"
-#include "framework/variable.h"
 #include "io.h"
 #include "test_helper.h"
 #include <map>

tools/pre-commit.hooks/.clang-format.hook

+#!/bin/bash
+#set -e
+#
+#readonly VERSION="3.8"
+#
+#version=$(clang-format -version)
+#
+#if ! [[ $version == *"$VERSION"* ]]; then
+#    echo "clang-format version check failed."
+#    echo "a version contains '$VERSION' is needed, but get '$version'"
+#    echo "you can install the right version, and make an soft-link to '\$PATH' env"
+#    exit -1
+#fi
+
+clang-format $@

tools/pre-commit.hooks/.clang-tidy.hook

 #!/bin/bash
 
-echo "allonli clang-tidy formating init"
-
 cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-clang-foramt -version
-clang-tidy -version
-python ./tools/pre-commit.hooks/run-clang-tidy.py
+python ./tools/pre-commit.hooks/run-clang-tidy.py -header-filter=third-party/
 #TOTAL_ERRORS=0
 
 # The trick to remove deleted files: https://stackoverflow.com/a/2413151