add cl kernel

src/operators/fetch_op.cpp

@@ -14,7 +14,23 @@ limitations under the License. */
 
 #include "fetch_op.h"
 namespace paddle_mobile {
-namespace operators {}
+namespace operators {
+
+template <typename DeviceType, typename T>
+void FetchOp<DeviceType, T>::InferShape() const {
+  auto x_dims = this->param_.InputX()->dims();
+  this->param_.Out()->Resize(x_dims);
+}
+
+template <typename DeviceType, typename T>
+void FetchOp<DeviceType, T>::RunImpl() {
+#ifdef PADDLE_MOBILE_CL
+  this->kernel_.Compute(this->param_);
+#else
+  this->param_.Out()->ShareDataWith(*(this->param_.InputX()));
+#endif
+}
+}  // namespace operators
 }  // namespace paddle_mobile
 
 namespace ops = paddle_mobile::operators;

src/operators/fetch_op.h

@@ -16,6 +16,7 @@ limitations under the License. */
 
 #include <string>
 #include "framework/operator.h"
+#include "operators/kernel/fetch_kernel.h"
 #include "operators/op_param.h"
 
 namespace paddle_mobile {
@@ -23,25 +24,22 @@ namespace operators {
 using std::string;
 
 template <typename DeviceType, typename T>
-class FetchOp : public framework::OperatorBase<DeviceType> {
+class FetchOp
+    : public framework::OperatorWithKernel<DeviceType, FetchParam<DeviceType>,
+                                           FetchKernel<DeviceType, T>> {
  public:
   FetchOp(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) {}
-  void RunImpl() { param_.Out()->ShareDataWith(*param_.InputX()); }
+      : framework::OperatorWithKernel<DeviceType, FetchParam<DeviceType>,
+                                      FetchKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void Init() {}
+  void InferShape() const override;
 
-  void InferShape() const {
-    auto x_dims = param_.InputX()->dims();
-    param_.Out()->Resize(x_dims);
-  }
+  void RunImpl() override;
 
  protected:
-  FetchParam<DeviceType> param_;
 };
 
 }  // namespace operators

src/operators/kernel/cl/batchnorm_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. */
+
+#ifdef BATCHNORM_OP
+
+#include "operators/kernel/batchnorm_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <>
+bool BatchNormKernel<GPU_CL, float>::Init(BatchNormParam<GPU_CL> *param) {
+  return true;
+}
+
+template <>
+void BatchNormKernel<GPU_CL, float>::Compute(
+    const BatchNormParam<GPU_CL> &param) {}
+
+template class BatchNormKernel<GPU_CL, float>;
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/kernel/cl/fetch_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/fetch_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <>
+bool FetchKernel<GPU_CL, float>::Init(FetchParam<GPU_CL> *param) {
+  return true;
+}
+
+template <>
+void FetchKernel<GPU_CL, float>::Compute(const FetchParam<GPU_CL> &param) {}
+
+template class FetchKernel<GPU_CL, float>;
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/cl/pool_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. */
+
+#ifdef POOL_OP
+
+#include "operators/kernel/pool_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <>
+bool PoolKernel<GPU_CL, float>::Init(PoolParam<GPU_CL> *param) {
+  return true;
+}
+
+template <>
+void PoolKernel<GPU_CL, float>::Compute(const PoolParam<GPU_CL> &param) {}
+
+template class PoolKernel<GPU_CL, float>;
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+#endif

src/operators/kernel/fetch_kernel.h

+/* 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. */
+
+#pragma once
+
+#include "framework/operator.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+using namespace framework;
+
+template <typename DeviceType, typename T>
+class FetchKernel
+    : public framework::OpKernelBase<DeviceType, FetchParam<DeviceType>> {
+ public:
+  void Compute(const FetchParam<DeviceType> &param);
+  bool Init(FetchParam<DeviceType> *param);
+};
+
+}  // namespace operators
+}  // namespace paddle_mobile