add some function

src/framework/cl/cl_image.cpp

@@ -183,7 +183,7 @@ Print &operator<<(Print &printer, const CLImage &cl_image) {
       }
       i0 += width * H;
     }
-    delete (imageData);
+    delete[](imageData);
     CL_CHECK_ERRORS(err);
 
   } else {
@@ -213,13 +213,14 @@ Print &operator<<(Print &printer, const CLImage &cl_image) {
       }
     }
 
+    delete[](imageData);
     CL_CHECK_ERRORS(err);
   }
 
   for (int i = 0; i < cl_image.numel(); i += stride) {
     printer << data[i] << " ";
   }
-  delete (data);
+  delete[](data);
   return printer;
 }
 #endif

src/operators/feed_op.cpp

@@ -15,20 +15,14 @@ limitations under the License. */
 #include "feed_op.h"
 namespace paddle_mobile {
 namespace operators {
-#ifdef PADDLE_MOBILE_CL
+
 template <typename DeviceType, typename T>
 void FeedOp<DeviceType, T>::InferShape() const {
   auto out_dims = this->param_.Out()->dims();
   out_dims[0] = this->param_.BatchSize();
   this->param_.Out()->Resize(out_dims);
 }
-
-template <typename DeviceType, typename T>
-void FeedOp<DeviceType, T>::RunImpl() {
-  this->kernel_.Compute(this->param_);
-}
-#endif
-}
+}  // namespace operators
 }  // namespace paddle_mobile
 
 namespace ops = paddle_mobile::operators;

src/operators/feed_op.h

@@ -22,7 +22,7 @@ limitations under the License. */
 namespace paddle_mobile {
 namespace operators {
 using std::string;
-#ifdef PADDLE_MOBILE_CL
+
 template <typename DeviceType, typename T>
 class FeedOp
     : public framework::OperatorWithKernel<DeviceType, FeedParam<DeviceType>,
@@ -34,80 +34,10 @@ class FeedOp
       : framework::OperatorWithKernel<DeviceType, FeedParam<DeviceType>,
                                       FeedKernel<DeviceType, T>>(
             type, inputs, outputs, attrs, scope) {}
-
   void InferShape() const override;
 
-  void RunImpl() override;
-
  protected:
 };
-#else
-template <typename DeviceType, typename T>
-class FeedOp : public framework::OperatorBase<DeviceType> {
- public:
-  FeedOp(const string &type, const VariableNameMap &inputs,
-         const VariableNameMap &outputs, const framework::AttributeMap attrs,
-         std::shared_ptr<framework::Scope> scope)
-      : framework::OperatorBase<DeviceType>(type, inputs, outputs, attrs,
-                                            scope),
-        param_(inputs, outputs, attrs, scope.get()) {}
-
-  void InferShape() const {
-    auto out_dims = param_.Out()->dims();
-    out_dims[0] = param_.BatchSize();
-    param_.Out()->Resize(out_dims);
-
-    //  note : mobile infershape iscalled when executer is created.  so  do not
-    //  pass lod here .
-    // it is empty
-  }
-
-#ifdef PADDLE_MOBILE_FPGA
-
-  void Init() {
-    Tensor *output = param_.Out();
-    fpga::format_fp16_ofm(output);
-  }
-
-  void RunImpl() const {
-    auto input =
-        reinterpret_cast<Tensor *>(const_cast<LoDTensor *>(param_.InputX()));
-    auto input_ptr = input->data<float>();
-    fpga::format_image(input);
-    Tensor *output = param_.Out();
-    auto output_ptr = output->data<float>();
-
-    fpga::BypassArgs args = {fpga::DATA_TYPE_FP32};
-
-    args.input_data_type = fpga::DATA_TYPE_FP32;
-    args.output_data_type = fpga::DATA_TYPE_FP16;
-    args.input_layout_type = fpga::LAYOUT_CHW;
-    args.output_layout_type = fpga::LAYOUT_HWC;
-    args.image.address = reinterpret_cast<void *>(input_ptr);
-    args.image.channels = (uint32_t)input->dims()[1];
-    args.image.height = (uint32_t)input->dims()[2];
-    args.image.width = (uint32_t)input->dims()[3];
-    args.image.pad_height = 0;
-    args.image.pad_width = 0;
-    args.output.address = output_ptr;
-    args.output.scale_address = output->scale;
-    fpga::PerformBypass(args);
-  }
-
-#else
-
-  void Init() {}
-  void RunImpl() {
-    param_.Out()->ShareDataWith(*param_.InputX());
-    param_.Out()->set_lod(param_.InputX()->lod());
-  }
-
- protected:
-  FeedParam<DeviceType> param_;
-};
-
-#endif
-#endif
 
 }  // namespace operators
 }  // namespace paddle_mobile

src/operators/kernel/arm/feed_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+
+#include "operators/kernel/feed_kernel.h"
+
+namespace paddle_mobile {
+    namespace operators {
+
+        template <>
+        bool FeedKernel<CPU, float>::Init(FeedParam<CPU> *param) {
+            return true;
+        }
+
+        template <>
+        void FeedKernel<CPU, float>::Compute(const FeedParam<CPU> &param) {
+            param.Out()->ShareDataWith(*(param.InputX()));
+            param.Out()->set_lod(param.InputX()->lod());
+        }
+
+        template class FeedKernel<CPU, float>;
+
+    }  // namespace operators
+}  // namespace paddle_mobile
+

src/operators/kernel/fpga/feed-kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/kernel/feed_kernel.h"
+
+namespace paddle_mobile {
+    namespace operators {
+
+        template <>
+        bool FeedKernel<FPGA, float>::Init(FeedParam<FPGA> *param) {
+            Tensor *output = param->Out();
+            fpga::format_fp16_ofm(output);
+            return true;
+        }
+
+        template <>
+        void FeedKernel<FPGA, float>::Compute(const FeedParam<FPGA> &param) {
+            auto input = reinterpret_cast<Tensor *>(const_cast<LoDTensor *>(param.InputX()));
+            auto input_ptr = input->data<float>();
+            fpga::format_image(input);
+            Tensor *output = param.Out();
+            auto output_ptr = output->data<float>();
+
+            fpga::BypassArgs args = {fpga::DATA_TYPE_FP32};
+
+            args.input_data_type = fpga::DATA_TYPE_FP32;
+            args.output_data_type = fpga::DATA_TYPE_FP16;
+            args.input_layout_type = fpga::LAYOUT_CHW;
+            args.output_layout_type = fpga::LAYOUT_HWC;
+            args.image.address = reinterpret_cast<void *>(input_ptr);
+            args.image.channels = (uint32_t)input->dims()[1];
+            args.image.height = (uint32_t)input->dims()[2];
+            args.image.width = (uint32_t)input->dims()[3];
+            args.image.pad_height = 0;
+            args.image.pad_width = 0;
+            args.output.address = output_ptr;
+            args.output.scale_address = output->scale;
+            fpga::PerformBypass(args);
+        }
+        template class FeedKernel<FPGA, float>;
+
+    }  // namespace operators
+}  // namespace paddle_mobile
+

src/operators/kernel/mali/feed_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/kernel/feed_kernel.h"
+
+namespace paddle_mobile {
+    namespace operators {
+
+
+        template <>
+        bool FeedKernel<GPU_MALI, float>::Init(
+                FeedParam<GPU_MALI> *param) {
+            return true;
+        }
+
+        template <>
+        void FeedKernel<GPU_MALI, float>::Compute(
+                const FeedParam<GPU_MALI> &param) {
+        }
+
+        template class FeedKernel<GPU_MALI, float>;
+
+    }  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/op_param.h

@@ -1255,6 +1255,7 @@ class ReluParam : public ReluParamBase<Dtype> {
   using ReluParamBase<Dtype>::ReluParamBase;
 };
 
+#ifdef PADDLE_MOBILE_CL
 template <>
 class ReluParam<GPU_CL> : public ReluParamBase<GPU_CL> {
  public:
@@ -1264,6 +1265,7 @@ class ReluParam<GPU_CL> : public ReluParamBase<GPU_CL> {
  private:
   framework::CLImage midImage;
 };
+#endif
 
 #endif