update FPGA support op and related files

src/operators/fusion_conv_add_relu_op.h

@@ -31,7 +31,7 @@ class FusionConvAddReluOpMatcher : public framework::FusionOpMatcher {
   FusionConvAddReluOpMatcher() {
     node_ = framework::Node(G_OP_TYPE_CONV);
     node_ > std::make_shared<framework::Node>(G_OP_TYPE_ELEMENTWISE_ADD) >
-            std::make_shared<framework::Node>(G_OP_TYPE_RELU);
+        std::make_shared<framework::Node>(G_OP_TYPE_RELU);
   }
 
   void FolderNodes(

src/operators/fusion_deconv_add_op.h

@@ -34,8 +34,8 @@ class FusionDeconvAddMatcher : public framework::FusionOpMatcher {
   void FolderNodes(
       framework::Node *node,
       std::vector<std::shared_ptr<framework::Node>> *removed_nodes) {
-      node->Folder(node_.Depth(), Type(),
-                   {{G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}}, removed_nodes);
+    node->Folder(node_.Depth(), Type(),
+                 {{G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}}, removed_nodes);
   }
 
   std::string Type() { return G_OP_TYPE_FUSION_DECONV_ADD; }
@@ -43,17 +43,17 @@ class FusionDeconvAddMatcher : public framework::FusionOpMatcher {
 
 template <typename DeviceType, typename T>
 class FusionDeconvAddOp : public framework::OperatorWithKernel<
-                               DeviceType, FusionDeconvAddParam<DeviceType>,
-                               operators::DeconvAddKernel<DeviceType, T>> {
+                              DeviceType, FusionDeconvAddParam<DeviceType>,
+                              operators::DeconvAddKernel<DeviceType, T>> {
  public:
   FusionDeconvAddOp(const string &type, const VariableNameMap &inputs,
-                     const VariableNameMap &outputs,
-                     const framework::AttributeMap &attrs,
-                     std::shared_ptr<framework::Scope> scope)
+                    const VariableNameMap &outputs,
+                    const framework::AttributeMap &attrs,
+                    std::shared_ptr<framework::Scope> scope)
       : framework::OperatorWithKernel<
             DeviceType, FusionDeconvAddParam<DeviceType>,
             operators::DeconvAddKernel<DeviceType, T>>(type, inputs, outputs,
-                                                        attrs, scope) {}
+                                                       attrs, scope) {}
 
   void InferShape() const {
     auto input = this->param_.Input();

src/operators/fusion_deconv_add_relu_op.cpp

@@ -21,7 +21,8 @@ namespace operators {}
 }  // namespace paddle_mobile
 
 namespace ops = paddle_mobile::operators;
-REGISTER_FUSION_MATCHER(fusion_deconv_add_relu, ops::FusionDeconvAddReluMatcher);
+REGISTER_FUSION_MATCHER(fusion_deconv_add_relu,
+                        ops::FusionDeconvAddReluMatcher);
 #ifdef PADDLE_MOBILE_CPU
 #endif
 #ifdef PADDLE_MOBILE_MALI_GPU

src/operators/fusion_deconv_add_relu_op.h

@@ -29,32 +29,33 @@ class FusionDeconvAddReluMatcher : public framework::FusionOpMatcher {
   FusionDeconvAddReluMatcher() {
     node_ = framework::Node(G_OP_TYPE_CONV_TRANSPOSE);
     node_ > std::make_shared<framework::Node>(G_OP_TYPE_ELEMENTWISE_ADD) >
-            std::make_shared<framework::Node>(G_OP_TYPE_RELU);
+        std::make_shared<framework::Node>(G_OP_TYPE_RELU);
   }
 
   void FolderNodes(
       framework::Node *node,
       std::vector<std::shared_ptr<framework::Node>> *removed_nodes) {
-      node->Folder(node_.Depth(), Type(),
-                   {{G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}}, removed_nodes);
+    node->Folder(node_.Depth(), Type(),
+                 {{G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}}, removed_nodes);
   }
 
   std::string Type() { return G_OP_TYPE_FUSION_DECONV_ADD_RELU; }
 };
 
 template <typename DeviceType, typename T>
-class FusionDeconvAddReluOp : public framework::OperatorWithKernel<
-                               DeviceType, FusionDeconvAddReluParam<DeviceType>,
-                               operators::DeconvAddReluKernel<DeviceType, T>> {
+class FusionDeconvAddReluOp
+    : public framework::OperatorWithKernel<
+          DeviceType, FusionDeconvAddReluParam<DeviceType>,
+          operators::DeconvAddReluKernel<DeviceType, T>> {
  public:
   FusionDeconvAddReluOp(const string &type, const VariableNameMap &inputs,
-                     const VariableNameMap &outputs,
-                     const framework::AttributeMap &attrs,
-                     std::shared_ptr<framework::Scope> scope)
+                        const VariableNameMap &outputs,
+                        const framework::AttributeMap &attrs,
+                        std::shared_ptr<framework::Scope> scope)
       : framework::OperatorWithKernel<
             DeviceType, FusionDeconvAddReluParam<DeviceType>,
-            operators::DeconvAddReluKernel<DeviceType, T>>(type, inputs, outputs,
-                                                        attrs, scope) {}
+            operators::DeconvAddReluKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
   void InferShape() const {
     auto input = this->param_.Input();

src/operators/kernel/fpga/V2/deconv_add_relu_kernel.cpp

@@ -22,7 +22,8 @@ namespace paddle_mobile {
 namespace operators {
 
 template <>
-bool DeconvAddReluKernel<FPGA, float>::Init(FusionDeconvAddReluParam<FPGA> *param) {
+bool DeconvAddReluKernel<FPGA, float>::Init(
+    FusionDeconvAddReluParam<FPGA> *param) {
   return true;
 }
 

src/operators/kernel/fpga/V2/transpose2_kernel.cpp

@@ -25,8 +25,9 @@ bool Transpose2Kernel<FPGA, float>::Init(Transpose2Param<FPGA> *param) {
 }
 
 template <>
-void Transpose2Kernel<FPGA, float>::Compute(const Transpose2Param<FPGA> &param) {
-  //Transpose2Compute<float>(param);
+void Transpose2Kernel<FPGA, float>::Compute(
+    const Transpose2Param<FPGA> &param) {
+  // Transpose2Compute<float>(param);
 }
 
 }  // namespace operators

src/operators/op_param.h

@@ -2221,9 +2221,9 @@ class ConvTransposeParam : public OpParam {
                      const Scope &scope) {
     filter_ = FilterFrom<GType>(inputs, scope);
     input_ = InputFrom<GType>(inputs, scope);
-    //output_ = OutputFrom<GType>(outputs, scope);
+    // output_ = OutputFrom<GType>(outputs, scope);
     if (outputs.count("Output")) {
-        output_ = OpParam::OutputFrom<GType>(outputs, scope);
+      output_ = OpParam::OutputFrom<GType>(outputs, scope);
     }
     strides_ = GetAttr<vector<int>>("strides", attrs);
     paddings_ = GetAttr<vector<int>>("paddings", attrs);
@@ -2270,11 +2270,12 @@ template <typename Dtype>
 class FusionDeconvAddParam : public ConvTransposeParam<Dtype> {
   typedef typename DtypeTensorTrait<Dtype>::gtype GType;
   typedef typename DtypeTensorTrait<Dtype>::rtype RType;
-public:
+
+ public:
   FusionDeconvAddParam(const VariableNameMap &inputs,
-                     const VariableNameMap &outputs, const AttributeMap &attrs,
-                     const Scope &scope)
-      :ConvTransposeParam<Dtype>(inputs, outputs, attrs, scope) {
+                       const VariableNameMap &outputs,
+                       const AttributeMap &attrs, const Scope &scope)
+      : ConvTransposeParam<Dtype>(inputs, outputs, attrs, scope) {
     bias_ = OpParam::InputYFrom<GType>(inputs, scope);
     axis_ = OpParam::GetAttr<int>("axis", attrs);
     output_ = OpParam::OutFrom<GType>(outputs, scope);

src/operators/split_op.cpp

@@ -13,8 +13,8 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #ifdef SPLIT_OP
-#include <vector>
 #include "operators/split_op.h"
+#include <vector>
 
 namespace paddle_mobile {
 namespace operators {