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,14 +213,14 @@ Print &operator<<(Print &printer, const CLImage &cl_image) {
       }
     }
 
-    delete[](imageData);
+    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/framework/executor.cpp

@@ -948,7 +948,7 @@ void Executor<GPU_CL, Precision::FP32>::InitMemory() {
         cl_image->SetTensorData(tensorInput, ddim);
 
         delete origin_data;
-        //        paddle_mobile::memory::Free(tensorInput);
+        paddle_mobile::memory::Free(tensorInput);
       } else {
         if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
           auto cl_image = var->template GetMutable<framework::CLImage>();

src/operators/kernel/arm/feed_kernel.cpp

@@ -12,25 +12,23 @@ 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 {
+namespace operators {
 
-        template <>
-        bool FeedKernel<CPU, float>::Init(FeedParam<CPU> *param) {
-            return true;
-        }
+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 <>
+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>;
+template class FeedKernel<CPU, float>;
 
-    }  // namespace operators
+}  // 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

@@ -15,23 +15,22 @@ limitations under the License. */
 #include "operators/kernel/feed_kernel.h"
 
 namespace paddle_mobile {
-    namespace operators {
+namespace operators {
 
+template <>
+bool FeedKernel<GPU_MALI, float>::Init(FeedParam<GPU_MALI> *param) {
+  return true;
+}
 
-        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) {
+  param.Out()->ShareDataWith(*(param.InputX()));
+  param.Out()->set_lod(param.InputX()->lod());
+}
 
-        template <>
-        void FeedKernel<GPU_MALI, float>::Compute(
-                const FeedParam<GPU_MALI> &param) {
-        }
+template class FeedKernel<GPU_MALI, float>;
 
-        template class FeedKernel<GPU_MALI, float>;
-
-    }  // namespace operators
+}  // namespace operators
 }  // namespace paddle_mobile
 
 #endif