diff --git a/src/framework/operator.cpp b/src/framework/operator.cpp
index 0e8d6f97809f7a204acc74a8c5427d88a63949aa..36b4663cb603d29bb60cfc297899d1c300e8ca91 100644
--- a/src/framework/operator.cpp
+++ b/src/framework/operator.cpp
@@ -61,9 +61,5 @@ template class OperatorBase<CPU>;
 template class OperatorBase<FPGA>;
 template class OperatorBase<GPU_MALI>;
 
-template class OperatorWithKernel<CPU>;
-template class OperatorWithKernel<FPGA>;
-template class OperatorWithKernel<GPU_MALI>;
-
 }  // namespace framework
 }  // namespace paddle_mobile
diff --git a/src/framework/operator.h b/src/framework/operator.h
index 2ea7626711c4161bbbedd5e26cdc895c27cdcd83..6ca0999f706f5e4e62270745c55dc78ee82f9b65 100644
--- a/src/framework/operator.h
+++ b/src/framework/operator.h
@@ -103,16 +103,24 @@ class OperatorBase {
 /*
  * @b 这个类为所有带有运算的 op 的父类, 这个 op 继承与 OperatorBase
  * */
-template <typename Dtype>
+template <typename Dtype, typename ParamType, typename KernelType>
 class OperatorWithKernel : public OperatorBase<Dtype> {
  public:
   OperatorWithKernel(const std::string &type, const VariableNameMap &inputs,
                      const VariableNameMap &outputs, const AttributeMap &attrs,
                      std::shared_ptr<Scope> scope)
-      : OperatorBase<Dtype>(type, inputs, outputs, attrs, scope) {}
+      : OperatorBase<Dtype>(type, inputs, outputs, attrs, scope),
+        param_(inputs, outputs, attrs, *scope) {
+    kernel_.Init(param_);
+  }
+
+  virtual void RunImpl() const { this->kernel_.Compute(this->param_); }
 
-  virtual void RunImpl() const = 0;
   virtual void InferShape() const = 0;
+
+ protected:
+  KernelType kernel_;
+  ParamType param_;
 };
 
 /*
@@ -127,6 +135,7 @@ class OpKernelBase {
    *    所有结构体存在与: paddle-mobile/src/operators/op_param.h
    * */
   virtual void Compute(const P &para) const = 0;
+  virtual bool Init(const P &para) const { return true; };
   virtual ~OpKernelBase() = default;
 };
 
diff --git a/src/operators/batchnorm_op.cpp b/src/operators/batchnorm_op.cpp
index e36cb24b7c46039463b76635536f0af4c6407824..672e990be44c11df0795b9c6f301803f8ad02285 100644
--- a/src/operators/batchnorm_op.cpp
+++ b/src/operators/batchnorm_op.cpp
@@ -23,8 +23,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void BatchNormOp<Dtype, T>::InferShape() const {
-  auto x_dims = param_.InputX()->dims();
-  param_.OutputY()->Resize(x_dims);
+  auto x_dims = this->param_.InputX()->dims();
+  this->param_.OutputY()->Resize(x_dims);
 }
 template class BatchNormOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/batchnorm_op.h b/src/operators/batchnorm_op.h
index ea774662abc093c36f75ad693aff579323becb23..9ee0b2dcf6b6ec46fcb08cac88d3df275d33f7d6 100644
--- a/src/operators/batchnorm_op.h
+++ b/src/operators/batchnorm_op.h
@@ -25,26 +25,21 @@ namespace paddle_mobile {
 namespace operators {
 using std::string;
 template <typename DeviceType, typename T>
-class BatchNormOp : public framework::OperatorWithKernel<DeviceType> {
+class BatchNormOp
+    : public framework::OperatorWithKernel<DeviceType, BatchNormParam,
+                                           BatchNormKernel<DeviceType, T>> {
  public:
   BatchNormOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, BatchNormParam,
+                                      BatchNormKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::BatchNormKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  BatchNormParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/box_coder_op.cpp b/src/operators/box_coder_op.cpp
index 8dc5da43d0e5594830c48ab2934b0df1875c6a54..31891ed74266d599898dd7426eed5cd28f320ab6 100644
--- a/src/operators/box_coder_op.cpp
+++ b/src/operators/box_coder_op.cpp
@@ -21,11 +21,11 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void BoxCoderOp<Dtype, T>::InferShape() const {
-  auto input_priorbox_dims = param_.InputPriorBox()->dims();
-  auto input_priorboxvar_dims = param_.InputPriorBoxVar()->dims();
-  auto input_targetbox_dims = param_.InputTargetBox()->dims();
+  auto input_priorbox_dims = this->param_.InputPriorBox()->dims();
+  auto input_priorboxvar_dims = this->param_.InputPriorBoxVar()->dims();
+  auto input_targetbox_dims = this->param_.InputTargetBox()->dims();
 
-  auto code_type = param_.CodeType();
+  auto code_type = this->param_.CodeType();
 
   if (code_type == "encode_center_size") {
     if (input_targetbox_dims.size() != 2) {
@@ -44,7 +44,7 @@ void BoxCoderOp<Dtype, T>::InferShape() const {
       LOG(kLOG_ERROR) << " dimension not match";
     }
   }
-  param_.OutputBox()->Resize(framework::make_ddim(
+  this->param_.OutputBox()->Resize(framework::make_ddim(
       {input_targetbox_dims[0], input_priorbox_dims[0], 4}));
 }
 template class BoxCoderOp<CPU, float>;
diff --git a/src/operators/box_coder_op.h b/src/operators/box_coder_op.h
index 001ef20023a4500adec558e6f0bddb16a3c65551..33ff2358bc8285a026c217ed11c2250769395567 100644
--- a/src/operators/box_coder_op.h
+++ b/src/operators/box_coder_op.h
@@ -28,26 +28,24 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class BoxCoderOp : public framework::OperatorWithKernel<DeviceType> {
+class BoxCoderOp
+    : public framework::OperatorWithKernel<
+          DeviceType, BoxCoderParam, operators::BoxCoderKernel<DeviceType, T>> {
  public:
   BoxCoderOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, BoxCoderParam,
+                                      operators::BoxCoderKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::BoxCoderKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, BoxCoderParam,
+      operators::BoxCoderKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  BoxCoderParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/concat_op.cpp b/src/operators/concat_op.cpp
index b9eacde60ee25a91769317bd441058b4afb3f296..f5a9c3d81ef34ac9ff643dd174741e083c879cbc 100644
--- a/src/operators/concat_op.cpp
+++ b/src/operators/concat_op.cpp
@@ -21,7 +21,7 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void ConcatOp<Dtype, T>::InferShape() const {
-  auto inputs = param_.Inputs();
+  auto inputs = this->param_.Inputs();
   const size_t n = inputs.size();
 
   std::vector<DDim> inputs_dims;
@@ -30,7 +30,7 @@ void ConcatOp<Dtype, T>::InferShape() const {
     inputs_dims.push_back(inputs[i]->dims());
   }
 
-  auto axis = static_cast<size_t>(param_.Axis());
+  auto axis = static_cast<size_t>(this->param_.Axis());
 
   if (n == 1) {
     DLOG << "Warning: concat op have only one input, "
@@ -54,7 +54,7 @@ void ConcatOp<Dtype, T>::InferShape() const {
     out_dims[axis] = -1;
   }
 
-  param_.Out()->Resize(out_dims);
+  this->param_.Out()->Resize(out_dims);
 }
 template class ConcatOp<CPU, float>;
 
diff --git a/src/operators/concat_op.h b/src/operators/concat_op.h
index fff704e4d858a7c67a0e8331089d8e8d5d4639fb..93612c6b1b6d1f6aa992773ef5cccc0c93f1b6e8 100644
--- a/src/operators/concat_op.h
+++ b/src/operators/concat_op.h
@@ -24,25 +24,23 @@ namespace paddle_mobile {
 namespace operators {
 using std::string;
 template <typename DeviceType, typename T>
-class ConcatOp : public framework::OperatorWithKernel<DeviceType> {
+class ConcatOp
+    : public framework::OperatorWithKernel<
+          DeviceType, ConcatParam, operators::ConcatKernel<DeviceType, T>> {
  public:
   ConcatOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, ConcatParam,
+                                      operators::ConcatKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::ConcatKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, ConcatParam,
+      operators::ConcatKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  ConcatParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/conv_op.cpp b/src/operators/conv_op.cpp
index 4be442f6169f65be9cffb2710f4f3aae40e9c905..b4910eb26eda0afc353c57a68eabece07c3d0f50 100644
--- a/src/operators/conv_op.cpp
+++ b/src/operators/conv_op.cpp
@@ -24,12 +24,12 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void ConvOp<Dtype, T>::InferShape() const {
-  auto in_dims = param_.Input()->dims();
-  auto filter_dims = param_.Filter()->dims();
-  const std::vector<int> &strides = param_.Strides();
-  std::vector<int> paddings = param_.Paddings();
-  int groups = param_.Groups();
-  std::vector<int> dilations = param_.Dilations();
+  auto in_dims = this->param_.Input()->dims();
+  auto filter_dims = this->param_.Filter()->dims();
+  const std::vector<int> &strides = this->param_.Strides();
+  std::vector<int> paddings = this->param_.Paddings();
+  int groups = this->param_.Groups();
+  std::vector<int> dilations = this->param_.Dilations();
 
   PADDLE_MOBILE_ENFORCE((in_dims.size() == filter_dims.size() &&
                          dilations.size() == paddings.size() &&
@@ -44,7 +44,7 @@ void ConvOp<Dtype, T>::InferShape() const {
   }
 
   framework::DDim ddim = framework::make_ddim(output_shape);
-  param_.Output()->Resize(ddim);
+  this->param_.Output()->Resize(ddim);
 }
 
 template class ConvOp<CPU, float>;
diff --git a/src/operators/conv_op.h b/src/operators/conv_op.h
index 0a26ce6c3f1ee005e982f10dcc3b38853124bdfb..fe723c574ef50dfbcede6bc87def3d797859dbf5 100644
--- a/src/operators/conv_op.h
+++ b/src/operators/conv_op.h
@@ -24,26 +24,23 @@ namespace paddle_mobile {
 namespace operators {
 using std::string;
 template <typename DeviceType, typename T>
-class ConvOp : public framework::OperatorWithKernel<DeviceType> {
+class ConvOp
+    : public framework::OperatorWithKernel<
+          DeviceType, ConvParam, operators::ConvKernel<DeviceType, T>> {
  public:
   ConvOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, ConvParam,
+                                      operators::ConvKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, ConvParam,
+      operators::ConvKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
-  void RunImpl() const {
-    operators::ConvKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"Filter", "Input"});
-  }
-
  private:
-  ConvParam param_;
 };
 
 inline int ConvOutputSize(int input_size, int filter_size, int dilation,
diff --git a/src/operators/depthwise_conv_op.cpp b/src/operators/depthwise_conv_op.cpp
index 55198fd1160dd1c62cea12879c80539b71690822..be3b9a0ca851e82064cbab866b4b25341018729e 100644
--- a/src/operators/depthwise_conv_op.cpp
+++ b/src/operators/depthwise_conv_op.cpp
@@ -25,12 +25,12 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void DepthwiseConvOp<Dtype, T>::InferShape() const {
-  auto in_dims = param_.Input()->dims();
-  auto filter_dims = param_.Filter()->dims();
-  const std::vector<int> &strides = param_.Strides();
-  std::vector<int> paddings = param_.Paddings();
-  int groups = param_.Groups();
-  std::vector<int> dilations = param_.Dilations();
+  auto in_dims = this->param_.Input()->dims();
+  auto filter_dims = this->param_.Filter()->dims();
+  const std::vector<int> &strides = this->param_.Strides();
+  std::vector<int> paddings = this->param_.Paddings();
+  int groups = this->param_.Groups();
+  std::vector<int> dilations = this->param_.Dilations();
 
   PADDLE_MOBILE_ENFORCE((in_dims.size() == filter_dims.size() &&
                          dilations.size() == paddings.size() &&
@@ -45,7 +45,7 @@ void DepthwiseConvOp<Dtype, T>::InferShape() const {
   }
 
   framework::DDim ddim = framework::make_ddim(output_shape);
-  param_.Output()->Resize(ddim);
+  this->param_.Output()->Resize(ddim);
 }
 
 template class DepthwiseConvOp<CPU, float>;
diff --git a/src/operators/depthwise_conv_op.h b/src/operators/depthwise_conv_op.h
index 37ba1b9ada32d75cb715dd86221758c71c6b1929..75bcf44cb8790365e7f33719c481354c1a57c80a 100644
--- a/src/operators/depthwise_conv_op.h
+++ b/src/operators/depthwise_conv_op.h
@@ -24,27 +24,25 @@ namespace paddle_mobile {
 namespace operators {
 
 template <typename DeviceType, typename T>
-class DepthwiseConvOp : public framework::OperatorWithKernel<DeviceType> {
+class DepthwiseConvOp : public framework::OperatorWithKernel<
+                            DeviceType, ConvParam,
+                            operators::DepthwiseConvKernel<DeviceType, T>> {
  public:
   DepthwiseConvOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : framework::OperatorWithKernel<
+            DeviceType, ConvParam,
+            operators::DepthwiseConvKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
+
+  using framework::OperatorWithKernel<
+      DeviceType, ConvParam,
+      operators::DepthwiseConvKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
-  void RunImpl() const {
-    operators::DepthwiseConvKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"Filter", "Input"});
-  }
-
  private:
-  ConvParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/elementwise_add_op.cpp b/src/operators/elementwise_add_op.cpp
index 5333dcfdb6602e7be235c4faa3651a86502bc8a4..966bc9c1e77a4ae6e33bc830c06ba7593c7ba3e0 100644
--- a/src/operators/elementwise_add_op.cpp
+++ b/src/operators/elementwise_add_op.cpp
@@ -21,8 +21,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void ElementwiseAddOp<Dtype, T>::InferShape() const {
-  auto x_dim = param_.InputX()->dims();
-  param_.Out()->Resize(x_dim);
+  auto x_dim = this->param_.InputX()->dims();
+  this->param_.Out()->Resize(x_dim);
 }
 template class ElementwiseAddOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/elementwise_add_op.h b/src/operators/elementwise_add_op.h
index 62034b14edcbc9ec6ad44af59f6927b8cfa38aa2..6cb80d06d0a4d66935c77a3c23a6264d0be53ecc 100644
--- a/src/operators/elementwise_add_op.h
+++ b/src/operators/elementwise_add_op.h
@@ -25,26 +25,25 @@ namespace paddle_mobile {
 namespace operators {
 using std::string;
 template <typename DeviceType, typename T>
-class ElementwiseAddOp : public framework::OperatorWithKernel<DeviceType> {
+class ElementwiseAddOp : public framework::OperatorWithKernel<
+                             DeviceType, ElementwiseAddParam,
+                             operators::ElementwiseAddKernel<DeviceType, T>> {
  public:
   ElementwiseAddOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  void RunImpl() const {
-    operators::ElementwiseAddKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : framework::OperatorWithKernel<
+            DeviceType, ElementwiseAddParam,
+            operators::ElementwiseAddKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
+
+  using framework::OperatorWithKernel<
+      DeviceType, ElementwiseAddParam,
+      operators::ElementwiseAddKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  ElementwiseAddParam param_;
 };
 }  // namespace operators
 }  // namespace paddle_mobile
diff --git a/src/operators/fusion_conv_add.cpp b/src/operators/fusion_conv_add.cpp
index 21e13d87aff263db39e5a6105d49b9e6bdb9e97b..1f98cbdd8eb2ef6a386e0aa3d3106d69179f64d1 100644
--- a/src/operators/fusion_conv_add.cpp
+++ b/src/operators/fusion_conv_add.cpp
@@ -21,12 +21,12 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void FushionConvAddOp<Dtype, T>::InferShape() const {
-  auto in_dims = param_.Input()->dims();
-  auto filter_dims = param_.Filter()->dims();
-  const std::vector<int> &strides = param_.Strides();
-  std::vector<int> paddings = param_.Paddings();
-  int groups = param_.Groups();
-  std::vector<int> dilations = param_.Dilations();
+  auto in_dims = this->param_.Input()->dims();
+  auto filter_dims = this->param_.Filter()->dims();
+  const std::vector<int> &strides = this->param_.Strides();
+  std::vector<int> paddings = this->param_.Paddings();
+  int groups = this->param_.Groups();
+  std::vector<int> dilations = this->param_.Dilations();
 
   PADDLE_MOBILE_ENFORCE((in_dims.size() == filter_dims.size() &&
                          dilations.size() == paddings.size() &&
@@ -41,7 +41,7 @@ void FushionConvAddOp<Dtype, T>::InferShape() const {
   }
 
   framework::DDim ddim = framework::make_ddim(output_shape);
-  param_.Output()->Resize(ddim);
+  this->param_.Output()->Resize(ddim);
 }
 template class FushionConvAddOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/fusion_conv_add.h b/src/operators/fusion_conv_add.h
index dc35409b4666aafc7b19c23c02cf6003acdd7dc7..56ce40a53f0961a7b435e27954de86f6ffa6dbea 100644
--- a/src/operators/fusion_conv_add.h
+++ b/src/operators/fusion_conv_add.h
@@ -47,27 +47,24 @@ class FusionConvAddMatcher : public framework::FusionOpMatcher {
 };
 
 template <typename DeviceType, typename T>
-class FushionConvAddOp : public framework::OperatorWithKernel<DeviceType> {
+class FushionConvAddOp : public framework::OperatorWithKernel<
+                             DeviceType, FushionConvAddParam,
+                             operators::ConvAddKernel<DeviceType, T>> {
  public:
   FushionConvAddOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, FushionConvAddParam,
+                                      operators::ConvAddKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::ConvAddKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"Filter", "Input", "Y"});
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, FushionConvAddParam,
+      operators::ConvAddKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  FushionConvAddParam param_;
 };
 
 inline int ConvOutputSize(int input_size, int filter_size, int dilation,
diff --git a/src/operators/fusion_fc_op.cpp b/src/operators/fusion_fc_op.cpp
index c85de862027fb21bcbde77dbc9cba22e7e2811d9..65c1605a5df521b64571d279e3aa9c2d31aacfb6 100644
--- a/src/operators/fusion_fc_op.cpp
+++ b/src/operators/fusion_fc_op.cpp
@@ -20,10 +20,10 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void FushionFcOp<Dtype, T>::InferShape() const {
-  auto x_dims = param_.InputX()->dims();
-  auto y_dims = param_.InputY()->dims();
-  int x_num_col_dims = param_.XNumColDims();
-  int y_num_col_dims = param_.YNumColDims();
+  auto x_dims = this->param_.InputX()->dims();
+  auto y_dims = this->param_.InputY()->dims();
+  int x_num_col_dims = this->param_.XNumColDims();
+  int y_num_col_dims = this->param_.YNumColDims();
 
   assert(x_dims.size() > x_num_col_dims);
   assert(y_dims.size() > y_num_col_dims);
@@ -47,7 +47,7 @@ void FushionFcOp<Dtype, T>::InferShape() const {
   }
 
   framework::DDim ddim = framework::make_ddim(output_dims);
-  param_.Out()->Resize(ddim);
+  this->param_.Out()->Resize(ddim);
 }
 template class FushionFcOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/fusion_fc_op.h b/src/operators/fusion_fc_op.h
index 839ef07b244e84675cd186f267493eb29095d7e8..fbdad1e79cb0def207fdf18919fa54ce81c0286d 100644
--- a/src/operators/fusion_fc_op.h
+++ b/src/operators/fusion_fc_op.h
@@ -45,26 +45,25 @@ class FusionFcMatcher : public framework::FusionOpMatcher {
 };
 
 template <typename DeviceType, typename T>
-class FushionFcOp : public framework::OperatorWithKernel<DeviceType> {
+class FushionFcOp : public framework::OperatorWithKernel<
+                        DeviceType, FushionFcParam,
+                        operators::FushionFcKernel<DeviceType, T>> {
  public:
   FushionFcOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  void RunImpl() const {
-    operators::FushionFcKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : framework::OperatorWithKernel<
+            DeviceType, FushionFcParam,
+            operators::FushionFcKernel<DeviceType, T>>(type, inputs, outputs,
+                                                       attrs, scope) {}
+
+  using framework::OperatorWithKernel<
+      DeviceType, FushionFcParam,
+      operators::FushionFcKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  FushionFcParam param_;
 };
 
 #ifdef PADDLE_MOBILE_CPU
diff --git a/src/operators/kernel/arm/batchnorm_kernel.cpp b/src/operators/kernel/arm/batchnorm_kernel.cpp
index 30d922a777b67a55a7d0dfa98a55144bcb569d49..cb30fb41e936543737cd48717920c6a62fb19033 100644
--- a/src/operators/kernel/arm/batchnorm_kernel.cpp
+++ b/src/operators/kernel/arm/batchnorm_kernel.cpp
@@ -61,19 +61,20 @@ void BatchNormKernel<CPU, float>::Compute(const BatchNormParam &param) const {
     /// std = (var + epsilon).sqrt();
     /// inv_std = 1 / std;
     for (int i = 0; i < C * 4; i += 4) {
+      int index = i / 4;
       inv_std_ptr[i] =
-          1 / static_cast<float>(pow((variance_ptr[i / 4] + epsilon), 0.5));
+          1 / static_cast<float>(pow((variance_ptr[index] + epsilon), 0.5));
       inv_std_ptr[i + 1] = inv_std_ptr[i];
       inv_std_ptr[i + 2] = inv_std_ptr[i];
       inv_std_ptr[i + 3] = inv_std_ptr[i];
 
-      new_scale_ptr[i] = inv_std_ptr[i] * scale_ptr[i / 4];
+      new_scale_ptr[i] = inv_std_ptr[i] * scale_ptr[index];
       new_scale_ptr[i + 1] = new_scale_ptr[i];
       new_scale_ptr[i + 2] = new_scale_ptr[i];
       new_scale_ptr[i + 3] = new_scale_ptr[i];
 
       new_bias_ptr[i] =
-          bias_ptr[i / 4] - mean_ptr[i / 4] * inv_std_ptr[i] * scale_ptr[i / 4];
+          bias_ptr[index] - mean_ptr[index] * inv_std_ptr[i] * scale_ptr[index];
 
       new_bias_ptr[i + 1] = new_bias_ptr[i];
       new_bias_ptr[i + 2] = new_bias_ptr[i];
@@ -164,21 +165,21 @@ void BatchNormKernel<CPU, float>::Compute(const BatchNormParam &param) const {
         "vadd.f32   q7,  q7,  q10 \n\t"
         "vadd.f32   q8,  q8,  q10 \n\t"
 
-        "add %[out_ptr], %[out_ptr], r6       \n\t"
+        "add %[out_ptr], %[out_ptr], r6         \n\t"
         "vst1.32 {q1, q2}, [%[out_ptr]]!        \n\t"
-        "vst1.32 {q3, q4}, [%[out_ptr]]!       \n\t"
-        "vst1.32 {q5, q6}, [%[out_ptr]]!       \n\t"
-        "vst1.32 {q7, q8}, [%[out_ptr]]!       \n\t"
+        "vst1.32 {q3, q4}, [%[out_ptr]]!        \n\t"
+        "vst1.32 {q5, q6}, [%[out_ptr]]!        \n\t"
+        "vst1.32 {q7, q8}, [%[out_ptr]]!        \n\t"
 
-        "end_remainder_%=:                     \n\t"
+        "end_remainder_%=:                      \n\t"
 
         "subs %[C], %[C], #1                    \n\t"
         "bge        loop_c_%=                   \n\t"
         "end_c_%=:                              \n\t"
 
-        "subs %[N], %[N], #1                  \n\t"
-        "bge        loop_n_%=                \n\t"
-        "end_n_%=:                           \n\t"
+        "subs %[N], %[N], #1                    \n\t"
+        "bge        loop_n_%=                   \n\t"
+        "end_n_%=:                              \n\t"
         :
         : [input_x_ptr] "r"(input_x_ptr), [out_ptr] "r"(out_ptr),
           [new_scale_ptr] "r"(new_scale_ptr), [new_bias_ptr] "r"(new_bias_ptr),
@@ -232,6 +233,7 @@ void BatchNormKernel<CPU, float>::Compute(const BatchNormParam &param) const {
     //    DLOG << "out_ptr : " << out_ptr[102];
   }
 }
+
 }  // namespace operators
 }  // namespace paddle_mobile
 
diff --git a/src/operators/kernel/mali/conv_kernel.cpp b/src/operators/kernel/mali/conv_kernel.cpp
index 695f937880328e8c2ffed91a8beee23e9a72899a..6c140145e93fd5a8121d7026297bf51d32ab6de6 100644
--- a/src/operators/kernel/mali/conv_kernel.cpp
+++ b/src/operators/kernel/mali/conv_kernel.cpp
@@ -20,7 +20,10 @@ namespace paddle_mobile {
 namespace operators {
 
 template <>
-void ConvKernel<GPU_MALI, float>::Compute(const ConvParam &param) const {}
+void ConvKernel<GPU_MALI, float>::Compute(const ConvParam &param) const {
+  //  ArmConvImplement imp;
+  //  imp.Compute(param);
+}
 
 template class ConvKernel<GPU_MALI, float>;
 }  // namespace operators
diff --git a/src/operators/lrn_op.cpp b/src/operators/lrn_op.cpp
index d159cdf21b4d0f9ab85d24112ecb2a66729a0236..2533ab19a5084513a991082f148d546cb0059657 100644
--- a/src/operators/lrn_op.cpp
+++ b/src/operators/lrn_op.cpp
@@ -21,8 +21,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void LrnOp<Dtype, T>::InferShape() const {
-  auto x_dims = param_.InputX()->dims();
-  param_.Out()->Resize(x_dims);
+  auto x_dims = this->param_.InputX()->dims();
+  this->param_.Out()->Resize(x_dims);
 }
 template class LrnOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/lrn_op.h b/src/operators/lrn_op.h
index c0f7abba0bd095c7408787eda3b819a81fa2227e..d67b9f6be741581918b09d19a8a8b26c28ceed1c 100644
--- a/src/operators/lrn_op.h
+++ b/src/operators/lrn_op.h
@@ -25,25 +25,22 @@ namespace paddle_mobile {
 namespace operators {
 using std::string;
 template <typename DeviceType, typename T>
-class LrnOp : public framework::OperatorWithKernel<DeviceType> {
+class LrnOp : public framework::OperatorWithKernel<
+                  DeviceType, LrnParam, operators::LrnKernel<DeviceType, T>> {
  public:
   LrnOp(const 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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, LrnParam,
+                                      operators::LrnKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::LrnKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, LrnParam,
+      operators::LrnKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  LrnParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/mul_op.cpp b/src/operators/mul_op.cpp
index d33bcbfdddba06947c9d04711c39cb619ada536e..d97c6ec3e470bb2b083ef7e5234168c6fdfc34c1 100644
--- a/src/operators/mul_op.cpp
+++ b/src/operators/mul_op.cpp
@@ -21,10 +21,10 @@ namespace operators {
 
 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();
-  int y_num_col_dims = param_.YNumColDims();
+  auto x_dims = this->param_.InputX()->dims();
+  auto y_dims = this->param_.InputY()->dims();
+  int x_num_col_dims = this->param_.XNumColDims();
+  int y_num_col_dims = this->param_.YNumColDims();
 
   assert(x_dims.size() > x_num_col_dims);
   assert(y_dims.size() > y_num_col_dims);
@@ -48,7 +48,7 @@ void MulOp<Dtype, T>::InferShape() const {
   }
 
   framework::DDim ddim = framework::make_ddim(output_dims);
-  param_.Out()->Resize(ddim);
+  this->param_.Out()->Resize(ddim);
 }
 template class MulOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/mul_op.h b/src/operators/mul_op.h
index 5ecf6571ae2725975271d5b0e7212380caa47578..ad5c9a3702348455cb559c28453df82d81e1c4c8 100644
--- a/src/operators/mul_op.h
+++ b/src/operators/mul_op.h
@@ -25,25 +25,22 @@ namespace paddle_mobile {
 namespace operators {
 
 template <typename DeviceType, typename T>
-class MulOp : public framework::OperatorWithKernel<DeviceType> {
+class MulOp : public framework::OperatorWithKernel<
+                  DeviceType, MulParam, operators::MulKernel<DeviceType, T>> {
  public:
   MulOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, MulParam,
+                                      operators::MulKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::MulKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, MulParam,
+      operators::MulKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  MulParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/multiclass_nms_op.cpp b/src/operators/multiclass_nms_op.cpp
index e8b5f195feff617a5de55fe1a0b12a0e0cd70ce9..52adf6cc627d76b18b3b48928c344545327ca99e 100644
--- a/src/operators/multiclass_nms_op.cpp
+++ b/src/operators/multiclass_nms_op.cpp
@@ -20,8 +20,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void MultiClassNMSOp<Dtype, T>::InferShape() const {
-  auto input_bboxes_dims = param_.InputBBoxes()->dims();
-  auto input_scores_dims = param_.InputScores()->dims();
+  auto input_bboxes_dims = this->param_.InputBBoxes()->dims();
+  auto input_scores_dims = this->param_.InputScores()->dims();
   if (input_scores_dims.size() != 3) {
     LOG(kLOG_ERROR) << "Input Scores size must be 3";
   }
@@ -32,7 +32,7 @@ void MultiClassNMSOp<Dtype, T>::InferShape() const {
     LOG(kLOG_ERROR) << "Predict bboxes must be equal";
   }
   // pre size, will change in Compute.
-  param_.Out()->Resize(framework::make_ddim({input_bboxes_dims[1], 6}));
+  this->param_.Out()->Resize(framework::make_ddim({input_bboxes_dims[1], 6}));
 }
 template class MultiClassNMSOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/multiclass_nms_op.h b/src/operators/multiclass_nms_op.h
index 37f3742524f64b5bfa97f78a55f86b4264489dd5..30cf8f67942f7888599e8f0057baff1ddd5d6cea 100644
--- a/src/operators/multiclass_nms_op.h
+++ b/src/operators/multiclass_nms_op.h
@@ -28,26 +28,25 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class MultiClassNMSOp : public framework::OperatorWithKernel<DeviceType> {
+class MultiClassNMSOp : public framework::OperatorWithKernel<
+                            DeviceType, MultiClassNMSParam,
+                            operators::MultiClassNMSKernel<DeviceType, T>> {
  public:
   MultiClassNMSOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  void RunImpl() const {
-    operators::MultiClassNMSKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : framework::OperatorWithKernel<
+            DeviceType, MultiClassNMSParam,
+            operators::MultiClassNMSKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
+
+  using framework::OperatorWithKernel<
+      DeviceType, MultiClassNMSParam,
+      operators::MultiClassNMSKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  MultiClassNMSParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/pool_op.cpp b/src/operators/pool_op.cpp
index 79b06174af736f693e05fe87985bef1a02886435..e8a469d43141f0b880605b52216094c292ca50fb 100644
--- a/src/operators/pool_op.cpp
+++ b/src/operators/pool_op.cpp
@@ -34,13 +34,13 @@ int PoolOutputSize(int input_size, int filter_size, int padding, int stride,
 }
 template <typename DeviceType, typename T>
 void PoolOp<DeviceType, T>::InferShape() const {
-  auto in_x_dims = param_.Input()->dims();
-  std::vector<int> ksize = param_.Ksize();
-  std::vector<int> paddings = param_.Paddings();
-  std::vector<int> strides = param_.Strides();
-  bool ceil_mode = param_.isCeilMode();
+  auto in_x_dims = this->param_.Input()->dims();
+  std::vector<int> ksize = this->param_.Ksize();
+  std::vector<int> paddings = this->param_.Paddings();
+  std::vector<int> strides = this->param_.Strides();
+  bool ceil_mode = this->param_.isCeilMode();
 
-  if (param_.isGlobalPooling()) {
+  if (this->param_.isGlobalPooling()) {
     ksize.resize(static_cast<size_t>(in_x_dims.size()) - 2);
     for (size_t i = 0; i < ksize.size(); ++i) {
       paddings[i] = 0;
@@ -52,7 +52,7 @@ void PoolOp<DeviceType, T>::InferShape() const {
     output_shape.push_back(PoolOutputSize(in_x_dims[i + 2], ksize[i],
                                           paddings[i], strides[i], ceil_mode));
   }
-  param_.Output()->Resize(framework::make_ddim(output_shape));
+  this->param_.Output()->Resize(framework::make_ddim(output_shape));
 }
 template class PoolOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/pool_op.h b/src/operators/pool_op.h
index 8dc99ae686390041b3c99c2df71d91ae9801a1f2..5b436fb18bdc055add21acd37e5a1a9c7b6e5b02 100644
--- a/src/operators/pool_op.h
+++ b/src/operators/pool_op.h
@@ -29,24 +29,21 @@ using framework::OperatorWithKernel;
 using framework::Scope;
 using std::string;
 template <typename DeviceType, typename T>
-class PoolOp : public OperatorWithKernel<DeviceType> {
+class PoolOp : public OperatorWithKernel<DeviceType, PoolParam,
+                                         operators::PoolKernel<DeviceType, T>> {
  public:
   PoolOp(const string &type, const VariableNameMap &inputs,
          const VariableNameMap &outputs, const AttributeMap &attrs,
          std::shared_ptr<Scope> scope)
-      : OperatorWithKernel<DeviceType>(type, inputs, outputs, attrs, scope),
-        param_(inputs, outputs, attrs, *scope) {}
-  using OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : OperatorWithKernel<DeviceType, PoolParam,
+                           operators::PoolKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
+  using OperatorWithKernel<
+      DeviceType, PoolParam,
+      operators::PoolKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
-  void RunImpl() const {
-    operators::PoolKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"X"});
-  }
-
  private:
-  PoolParam param_;
 };
 }  // namespace operators
 }  // namespace paddle_mobile
diff --git a/src/operators/prior_box_op.cpp b/src/operators/prior_box_op.cpp
index f3ae6e5231efd604862e9c7b4dbafd71c71d6f54..44e1741b66f301aee55f1f4d33b9bb1173e6004d 100644
--- a/src/operators/prior_box_op.cpp
+++ b/src/operators/prior_box_op.cpp
@@ -21,13 +21,13 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void PriorBoxOp<Dtype, T>::InferShape() const {
-  auto input_dims = param_.Input()->dims();
-  auto input_image_dims = param_.InputImage()->dims();
-  auto min_sizes = param_.MinSizes();
-  auto max_sizes = param_.MaxSizes();
-  auto variances = param_.Variances();
-  auto aspect_ratios = param_.AspectRatios();
-  bool flip = param_.Flip();
+  auto input_dims = this->param_.Input()->dims();
+  auto input_image_dims = this->param_.InputImage()->dims();
+  auto min_sizes = this->param_.MinSizes();
+  auto max_sizes = this->param_.MaxSizes();
+  auto variances = this->param_.Variances();
+  auto aspect_ratios = this->param_.AspectRatios();
+  bool flip = this->param_.Flip();
   std::vector<float> aspect_ratios_vec;
   ExpandAspectRatios(aspect_ratios, flip, &aspect_ratios_vec);
 
@@ -41,8 +41,8 @@ void PriorBoxOp<Dtype, T>::InferShape() const {
   dim_vec[1] = input_dims[3];
   dim_vec[2] = num_priors;
   dim_vec[3] = 4;
-  param_.OutputBoxes()->Resize(framework::make_ddim(dim_vec));
-  param_.OutputVariances()->Resize(framework::make_ddim(dim_vec));
+  this->param_.OutputBoxes()->Resize(framework::make_ddim(dim_vec));
+  this->param_.OutputVariances()->Resize(framework::make_ddim(dim_vec));
 }
 template class PriorBoxOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/prior_box_op.h b/src/operators/prior_box_op.h
index e3de58b372cc101956d83ff39b02e172c990b254..5b3e3fffd6787360b69ff3af2d19bc8e05549c04 100644
--- a/src/operators/prior_box_op.h
+++ b/src/operators/prior_box_op.h
@@ -28,26 +28,24 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class PriorBoxOp : public framework::OperatorWithKernel<DeviceType> {
+class PriorBoxOp
+    : public framework::OperatorWithKernel<
+          DeviceType, PriorBoxParam, operators::PriorBoxKernel<DeviceType, T>> {
  public:
   PriorBoxOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, PriorBoxParam,
+                                      operators::PriorBoxKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::PriorBoxKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, PriorBoxParam,
+      operators::PriorBoxKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  PriorBoxParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/relu_op.cpp b/src/operators/relu_op.cpp
index 066772e3bee32b3296d7fb9bebf615cc57702871..cf495d8bdace83f5dd7f86d372d07b3241867af9 100644
--- a/src/operators/relu_op.cpp
+++ b/src/operators/relu_op.cpp
@@ -20,8 +20,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void ReluOp<Dtype, T>::InferShape() const {
-  auto input_dims = param_.InputX()->dims();
-  param_.Out()->Resize(input_dims);
+  auto input_dims = this->param_.InputX()->dims();
+  this->param_.Out()->Resize(input_dims);
 }
 template class ReluOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/relu_op.h b/src/operators/relu_op.h
index f032546c82d740c179385434b5d72082e4bd5a9d..8f9e55cf8a2d5bb58e85c21cd2cee3647b00fa22 100644
--- a/src/operators/relu_op.h
+++ b/src/operators/relu_op.h
@@ -28,7 +28,9 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class ReluOp : public framework::OperatorWithKernel<DeviceType> {
+class ReluOp
+    : public framework::OperatorWithKernel<
+          DeviceType, ReluParam, operators::ReluKernel<DeviceType, T>> {
  public:
   /*
    * @b op 的实例化方法, 需要调用父类的实例化方法, 以及实例化自己的参数结构体
@@ -36,27 +38,16 @@ class ReluOp : public framework::OperatorWithKernel<DeviceType> {
   ReluOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, ReluParam,
+                                      operators::ReluKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  /*
-   * @b op 进行运算, 调用相应的 kernel 进行运算
-   * */
-  void RunImpl() const {
-    operators::ReluKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, ReluParam,
+      operators::ReluKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  /*
-   * @b Relu kernel 进行运算时所需要用到参数的结构体,
-   *    结构体定义在: paddle-mobile/src/operators/op_param.h
-   * */
-  ReluParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/reshape_op.cpp b/src/operators/reshape_op.cpp
index 5d0aa49a26b6c0b2f78b5fcb4b3bd144edaa313c..0fdcaf4d1a95ccd2a0ceccdc6d890b30a1d66368 100644
--- a/src/operators/reshape_op.cpp
+++ b/src/operators/reshape_op.cpp
@@ -22,10 +22,10 @@ namespace operators {
 template <typename Dtype, typename T>
 void ReshapeOp<Dtype, T>::InferShape() const {
   /// todo: add InputShape() detection.
-  auto &shape = param_.Shape();
-  auto input_x_dims = param_.InputX()->dims();
+  auto &shape = this->param_.Shape();
+  auto input_x_dims = this->param_.InputX()->dims();
   auto out_dims = ValidateShape(shape, input_x_dims);
-  param_.Out()->Resize(out_dims);
+  this->param_.Out()->Resize(out_dims);
 }
 template class ReshapeOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/reshape_op.h b/src/operators/reshape_op.h
index a14c84b6be95a1d86ac645563dc21c21a51ca6d4..90d31153135f629585d56eb89ae12830215900d8 100644
--- a/src/operators/reshape_op.h
+++ b/src/operators/reshape_op.h
@@ -28,26 +28,24 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class ReshapeOp : public framework::OperatorWithKernel<DeviceType> {
+class ReshapeOp
+    : public framework::OperatorWithKernel<
+          DeviceType, ReshapeParam, operators::ReshapeKernel<DeviceType, T>> {
  public:
   ReshapeOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, ReshapeParam,
+                                      operators::ReshapeKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  void RunImpl() const {
-    operators::ReshapeKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, ReshapeParam,
+      operators::ReshapeKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
 
  protected:
-  ReshapeParam param_;
 };
 
 }  // namespace operators
diff --git a/src/operators/sigmoid_op.cpp b/src/operators/sigmoid_op.cpp
index 641b6f29f2f1eaff7304b8e70b12284575a2e246..79190e6c3368b9d375770062d948580779393f04 100644
--- a/src/operators/sigmoid_op.cpp
+++ b/src/operators/sigmoid_op.cpp
@@ -20,7 +20,7 @@ namespace paddle_mobile {
 namespace operators {
 template <typename DeviceType, typename T>
 void SigmoidOp<DeviceType, T>::InferShape() const {
-  param_.Out()->Resize(param_.InputX()->dims());
+  this->param_.Out()->Resize(this->param_.InputX()->dims());
 }
 template class SigmoidOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/sigmoid_op.h b/src/operators/sigmoid_op.h
index 7cdeb41af1b20ddf05ac80d7de0962c4bfe8dff4..bd914a63783f65c7b55d783f2bbcdf19c303c00f 100644
--- a/src/operators/sigmoid_op.h
+++ b/src/operators/sigmoid_op.h
@@ -25,28 +25,23 @@ limitations under the License. */
 namespace paddle_mobile {
 namespace operators {
 template <typename DeviceType, typename T>
-class SigmoidOp : public framework::OperatorWithKernel<DeviceType> {
+class SigmoidOp
+    : public framework::OperatorWithKernel<
+          DeviceType, SigmoidParam, operators::SigmoidKernel<DeviceType, T>> {
  public:
   SigmoidOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, SigmoidParam,
+                                      operators::SigmoidKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, SigmoidParam,
+      operators::SigmoidKernel<DeviceType, T>>::OperatorWithKernel;
 
   void InferShape() const override;
-
-  void RunImpl() const {
-    operators::SigmoidKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"X"});
-  }
-
- private:
-  SigmoidParam param_;
 };
 }  // namespace operators
 }  // namespace paddle_mobile
diff --git a/src/operators/softmax_op.cpp b/src/operators/softmax_op.cpp
index 8d5f669466d5725d877afe9db2adb9441fe488ca..e25b59198f3206357a770a104080f99bafa84dc5 100644
--- a/src/operators/softmax_op.cpp
+++ b/src/operators/softmax_op.cpp
@@ -20,7 +20,7 @@ namespace paddle_mobile {
 namespace operators {
 template <typename DeviceType, typename T>
 void SoftmaxOp<DeviceType, T>::InferShape() const {
-  param_.Out()->Resize(param_.InputX()->dims());
+  this->param_.Out()->Resize(this->param_.InputX()->dims());
 }
 template class SoftmaxOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/softmax_op.h b/src/operators/softmax_op.h
index 5cac4d8a3394b07e978ba41e18fd7fbb7f4756d7..1445ca055ea0472cdaa02d7496ff895feb9174bc 100644
--- a/src/operators/softmax_op.h
+++ b/src/operators/softmax_op.h
@@ -25,28 +25,25 @@ limitations under the License. */
 namespace paddle_mobile {
 namespace operators {
 template <typename DeviceType, typename T>
-class SoftmaxOp : public framework::OperatorWithKernel<DeviceType> {
+class SoftmaxOp
+    : public framework::OperatorWithKernel<
+          DeviceType, SoftmaxParam, operators::SoftmaxKernel<DeviceType, T>> {
  public:
   SoftmaxOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
+      : framework::OperatorWithKernel<DeviceType, SoftmaxParam,
+                                      operators::SoftmaxKernel<DeviceType, T>>(
+            type, inputs, outputs, attrs, scope) {}
 
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+  using framework::OperatorWithKernel<
+      DeviceType, SoftmaxParam,
+      operators::SoftmaxKernel<DeviceType, T>>::OperatorWithKernel;
 
   void InferShape() const override;
 
-  void RunImpl() const {
-    operators::SoftmaxKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-    this->ClearVariables({"X"});
-  }
-
  private:
-  SoftmaxParam param_;
 };
 }  // namespace operators
 }  // namespace paddle_mobile
diff --git a/src/operators/transpose_op.cpp b/src/operators/transpose_op.cpp
index 02a3b16e8d62d094a83c329f52957b4b8b87d805..989b277b9d58a8c029e041a89a1982f8994bae44 100644
--- a/src/operators/transpose_op.cpp
+++ b/src/operators/transpose_op.cpp
@@ -23,8 +23,8 @@ namespace operators {
 
 template <typename Dtype, typename T>
 void TransposeOp<Dtype, T>::InferShape() const {
-  auto input_x_dims = param_.InputX()->dims();
-  auto axis = param_.Axis();
+  auto input_x_dims = this->param_.InputX()->dims();
+  auto axis = this->param_.Axis();
 
   size_t x_dims_size = input_x_dims.size();
   size_t axis_size = axis.size();
@@ -45,7 +45,7 @@ void TransposeOp<Dtype, T>::InferShape() const {
   for (size_t i = 0; i < axis_size; i++) {
     out_dims[i] = input_x_dims[axis[i]];
   }
-  param_.Out()->Resize(out_dims);
+  this->param_.Out()->Resize(out_dims);
 }
 template class TransposeOp<CPU, float>;
 }  // namespace operators
diff --git a/src/operators/transpose_op.h b/src/operators/transpose_op.h
index f65a725756c858b8e2e304906ed8236b00046fc9..349220b58ff3e0daec8c7dc2e2dec969ced8b289 100644
--- a/src/operators/transpose_op.h
+++ b/src/operators/transpose_op.h
@@ -28,26 +28,23 @@ namespace operators {
 using paddle_mobile::framework::Tensor;
 
 template <typename DeviceType, typename T>
-class TransposeOp : public framework::OperatorWithKernel<DeviceType> {
+class TransposeOp : public framework::OperatorWithKernel<
+                        DeviceType, TransposeParam,
+                        operators::TransposeKernel<DeviceType, T>> {
  public:
   TransposeOp(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),
-        param_(inputs, outputs, attrs, *scope) {}
-
-  void RunImpl() const {
-    operators::TransposeKernel<DeviceType, T> kernel;
-    kernel.Compute(param_);
-  }
-
-  using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+      : framework::OperatorWithKernel<
+            DeviceType, TransposeParam,
+            operators::TransposeKernel<DeviceType, T>>(type, inputs, outputs,
+                                                       attrs, scope) {}
+
+  using framework::OperatorWithKernel<
+      DeviceType, TransposeParam,
+      operators::TransposeKernel<DeviceType, T>>::OperatorWithKernel;
   void InferShape() const override;
-
- protected:
-  TransposeParam param_;
 };
 
 }  // namespace operators
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 0cf3537ad64fb0dfb23d0514cf4d068b9c9c6199..cc707ded7f6682136974b4fb16e82f112bc5b24f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -137,6 +137,10 @@ else ()
     ADD_EXECUTABLE(test-depthwise-conv-op operators/test_depthwise_conv_op.cpp test_helper.h test_include.h executor_for_test.h)
     target_link_libraries(test-depthwise-conv-op paddle-mobile)
 
+    # gen test
+    ADD_EXECUTABLE(test-mobilenet net/test_mobilenet.cpp test_helper.h  test_include.h executor_for_test.h)
+    target_link_libraries(test-mobilenet paddle-mobile)
+
     #add_library(test-lib-size SHARED common/test_lib_size.h common/test_lib_size.cpp)
 
 endif()
diff --git a/test/net/test_mobilenet.cpp b/test/net/test_mobilenet.cpp
index 7ed9a3566e3be8d5baa7e47611fc713772e94327..8400b08f2292bb5655e2d85298acce603e1ce603 100644
--- a/test/net/test_mobilenet.cpp
+++ b/test/net/test_mobilenet.cpp
@@ -19,14 +19,14 @@ limitations under the License. */
 int main() {
   paddle_mobile::Loader<paddle_mobile::CPU> loader;
   auto time1 = time();
-  auto program = loader.Load(g_mobilenet, false);
+  auto program = loader.Load(g_mobilenet, true);
   auto time2 = time();
   DLOG << "load cost :" << time_diff(time1, time1) << "ms";
-  paddle_mobile::Executor<paddle_mobile::CPU> executor(program, 2, false);
+  paddle_mobile::Executor<paddle_mobile::CPU> executor(program, 1, true);
 
-  std::vector<int64_t> dims{2, 3, 224, 224};
+  std::vector<int64_t> dims{1, 3, 224, 224};
   Tensor input_tensor;
-  SetupTensor<float>(&input_tensor, {2, 3, 224, 224}, static_cast<float>(0),
+  SetupTensor<float>(&input_tensor, {1, 3, 224, 224}, static_cast<float>(0),
                      static_cast<float>(1));
 
   std::vector<float> input(input_tensor.data<float>(),