Merge branch 'develop' into develop

src/framework/operator.cpp

@@ -32,9 +32,6 @@ namespace paddle_mobile {
               scope_(scope) {
             CheckAllInputOutputSet();
         }
-
-        template <typename Dtype> void OperatorBase<Dtype>::Run() { RunImpl(); }
-
         template <typename Dtype>
         void OperatorBase<Dtype>::CheckAllInputOutputSet() const {}
 

src/framework/operator.h

@@ -18,72 +18,37 @@ SOFTWARE.
 
 #pragma once
 
-#include <map>
-
-#include "attribute.h"
-#include "block_desc.h"
-#include "common/type_define.h"
-#include "common/types.h"
-#include "common/variant.h"
-#include "op_info.h"
-#include "op_kernel_type.h"
-#include "paddle_mobile_object.h"
-#include "scope.h"
-#include "tensor.h"
-#include "variable.h"
+#include "framework/operator.h"
+#include "operators/kernel/pool_kernel.h"
 
 namespace paddle_mobile {
-    namespace framework {
-
-        template <typename Dtype> class OperatorBase : PaddleMobileObject {
-          public:
-            OperatorBase(const std::string &type, const VariableNameMap &inputs,
-                         const VariableNameMap &outputs,
-                         const AttributeMap &attrs,
-                         std::shared_ptr<Scope> scope);
-            virtual ~OperatorBase() {}
-            virtual void Run();
-            const VariableNameMap &Inputs() const { return inputs_; }
-            const VariableNameMap &Outputs() const { return outputs_; }
-            const std::string &Type() const { return type_; }
-            const AttributeMap &Attrs() const { return attrs_; }
-
-          protected:
-            std::shared_ptr<Scope> scope_;
-            std::string type_;
-            VariableNameMap inputs_;
-            VariableNameMap outputs_;
-            AttributeMap attrs_;
+    namespace operators {
 
-          private:
-            void CheckAllInputOutputSet() const;
-            virtual void RunImpl() const = 0;
-        };
+        using namespace framework;
 
-        template <typename Dtype>
-        class OperatorWithKernel : public OperatorBase<Dtype> {
+        template <typename DeviceType, typename T>
+        class ConvOp : public framework::OperatorWithKernel<DeviceType> {
           public:
-            OperatorWithKernel(const std::string &type,
-                               const VariableNameMap &inputs,
+            ConvOp(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) {}
-            virtual void InferShape() const = 0;
-
-          protected:
-            virtual void RunImpl() const = 0;
+                   const framework::AttributeMap &attrs,
+                   std::shared_ptr<framework::Scope> scope)
+                : framework::OperatorWithKernel<DeviceType>(
+                      type, inputs, outputs, attrs, scope),
+                  param_(inputs, outputs, attrs, *scope) {}
 
-          private:
-        };
+            using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
+            void InferShape() const override;
 
-        template <typename Dtype, typename P>
-        class OpKernelBase : PaddleMobileObject {
-          public:
-            virtual void Compute(const P &para) const = 0;
+            void Run() const {
+                operators::ConvKernel<DeviceType, T, ConvParam> kernel;
+                kernel.Compute(param_);
+                this->ClearVariables();
+            }
 
-            virtual ~OpKernelBase() = default;
+          private:
+            ConvParam param_;
         };
 
-    } // namespace framework
-} // namespace paddle_mobile
+    } // operators
+} // paddle_mobile

src/framework/variable.h

@@ -29,9 +29,6 @@ namespace paddle_mobile {
     namespace framework {
         class Variable : public PaddleMobileObject {
           public:
-            Variable() {}
-            ~Variable() {}
-
             template <typename T> const T *Get() const {
                 return static_cast<const T *>(holder_->Ptr());
             }

src/operators/conv_op.h

@@ -40,12 +40,13 @@ namespace paddle_mobile {
             using framework::OperatorWithKernel<DeviceType>::OperatorWithKernel;
             void InferShape() const override;
 
-          protected:
-            void RunImpl() const {
+            void Run() const {
                 operators::ConvKernel<DeviceType, T, ConvParam> kernel;
                 kernel.Compute(param_);
+                this->ClearVariables();
             }
 
+          private:
             ConvParam param_;
         };