add graph optimize, format code

src/common/log.cpp

+#include "log.h"
+
+namespace paddle_mobile {
+
+}

src/common/log.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
+#include <vector>
 #ifdef PADDLE_MOBILE_DEBUG
-
 #include <iostream>
 #include <sstream>
 #include <string>
-#include <vector>
+#endif
 
 namespace paddle_mobile {
 
+#ifdef PADDLE_MOBILE_DEBUG
+
 enum LogLevel {
   kNO_LOG,
   kLOG_ERROR,
@@ -111,7 +95,6 @@ struct ToLog {
          << (strrchr(__FILE__, '/') ? (strrchr(__FILE__, '/') + 1) : __FILE__) \
          << "] [line: " << __LINE__ << "] ")                                   \
             .str())
-}  // namespace paddle_mobile
 
 #define LOGF(level, format, ...)          \
   if (level > paddle_mobile::log_level) { \
@@ -125,8 +108,6 @@ struct ToLog {
 
 #else
 
-namespace paddle_mobile {
-
 enum LogLevel {
   kNO_LOG,
   kLOG_ERROR,
@@ -170,6 +151,17 @@ struct ToLog {
 #define LOGF(level, format, ...)
 
 #define DLOGF(format, ...)
-}  // namespace paddle_mobile
 
 #endif
+
+template <typename T>
+Print &operator<<(Print &printer, const std::vector<T> &v) {
+  printer << "[ ";
+  for (const auto &value : v) {
+    printer << value << " ";
+  }
+  printer << " ]";
+  return printer;
+}
+
+}  // namespace paddle_mobile
\ No newline at end of file

src/common/type_define.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
 #pragma once;
 
 #include <map>

src/common/types.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once;
 
 namespace paddle_mobile {

src/common/variant.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/

src/common/variant.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #include <iostream>
 
+#include "common/log.h"
+
 #pragma once
 
 namespace paddle_mobile {

src/framework/attribute.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
+#include "attribute.h"
 
 namespace paddle_mobile {
-namespace framework {}
+namespace framework {
+
+
+
+/*
+ * Variant<int, float, std::string, std::vector<int>, std::vector<float>,
+          std::vector<std::string>, bool, std::vector<bool>, BlockDesc *,
+          int64_t>
+ * */
+
+struct PrintVistor: Vistor<Print &>{
+  PrintVistor(Print &printer):printer_(printer){
+  }
+  template <typename T>
+  Print &operator()(const T &value){
+    printer_ << value;
+    return printer_;
+  }
+ private:
+  Print &printer_;
+};
+
+Print &operator<<(Print &printer, const Attribute &attr) {
+  Attribute::ApplyVistor(PrintVistor(printer), attr);
+//  std::vector<std::string> v = {"1", "2"};
+//  printer << (v);
+  return printer;
+}
+
+}
 }  // namespace paddle_mobile

src/framework/attribute.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
+#include "common/log.h"
 #include "common/variant.h"
-#include "framework.pb.h"
+#include "framework/framework.pb.h"
 
 namespace paddle_mobile {
 namespace framework {
@@ -104,6 +87,31 @@ class Attribute {
     return variant_.Get<T>();
   }
 
+  template <typename Vistor>
+  static typename Vistor::type_t ApplyVistor(Vistor vistor, Attribute attr) {
+    if (attr.variant_.TypeId() == typeid(int).hash_code()) {
+      return vistor(attr.variant_.Get<int>());
+    } else if (attr.variant_.TypeId() == typeid(float).hash_code()) {
+      return vistor(attr.variant_.Get<float>());
+    } else if (attr.variant_.TypeId() == typeid(std::string).hash_code()) {
+      return vistor(attr.variant_.Get<std::string>());
+    } else if (attr.variant_.TypeId() == typeid(std::vector<int>).hash_code()) {
+      return vistor(attr.variant_.Get<std::vector<int>>());
+    } else if (attr.variant_.TypeId() == typeid(std::vector<float>).hash_code()) {
+      return vistor(attr.variant_.Get<std::vector<float>>());
+    } else if (attr.variant_.TypeId() == typeid(std::vector<std::string>).hash_code()) {
+      return vistor(attr.variant_.Get<std::vector<std::string>>());
+    } else if (attr.variant_.TypeId() == typeid(bool).hash_code()) {
+      return vistor(attr.variant_.Get<bool>());
+    } else if (attr.variant_.TypeId() == typeid(std::vector<bool>).hash_code()) {
+      return vistor(attr.variant_.Get<std::vector<bool>>());
+    }  else if (attr.variant_.TypeId() == typeid(int64_t).hash_code()) {
+      return vistor(attr.variant_.Get<int64_t>());
+    } else {
+      throw std::bad_exception();
+    }
+  }
+
  private:
   Variant<int, float, std::string, std::vector<int>, std::vector<float>,
           std::vector<std::string>, bool, std::vector<bool>, BlockDesc *,
@@ -130,5 +138,10 @@ class AttrReader {
   const AttributeMap &attrs_;
 };
 
+
+
+
+Print &operator<<(Print &printer, const Attribute &op_desc);
+
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/data_layout.h

-/* Copyright (c) 2016 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 <cctype>

src/framework/ddim.cc

@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "ddim.h"
+#include <algorithm>
 
 namespace paddle_mobile {
 namespace framework {

src/framework/executor.h

@@ -18,11 +18,11 @@ limitations under the License. */
 #include <string>
 #include <vector>
 
-#include "block_desc.h"
+#include "framework/program/block_desc.h"
 #include "framework.pb.h"
 #include "operator.h"
-#include "program.h"
-#include "program_desc.h"
+#include "framework/program/program.h"
+#include "framework/program/program_desc.h"
 #include "scope.h"
 #include "tensor.h"
 #include "variable.h"

src/framework/framework.pb.h

@@ -124,7 +124,7 @@ void AddDescriptors();
 void InitDefaults();
 }  // namespace protobuf_framework_2eproto
 
-enum VarType_Type {
+enum  VarType_Type {
   VarType_Type_BOOL = 0,
   VarType_Type_INT16 = 1,
   VarType_Type_INT32 = 2,

src/framework/op_desc.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#pragma once
-
-#include "common/type_define.h"
-#include "framework.pb.h"
-#include "paddle_mobile_object.h"
-
-namespace paddle_mobile {
-namespace framework {
-
-class OpDesc : PaddleMobileObject {
- public:
-  OpDesc(const proto::OpDesc &desc);
-  const std::vector<std::string> &Input(const std::string &name) const;
-  const std::vector<std::string> &Output(const std::string &name) const;
-  Attribute GetAttr(const std::string &name) const;
-
-  const VariableNameMap &GetInputs() { return inputs_; }
-
-  const VariableNameMap &GetOutputs() { return outputs_; }
-
-  const AttributeMap &GetAttrMap() const;
-
-  const std::string &Type() { return desc_.type(); };
-
- private:
-  proto::OpDesc desc_;
-  VariableNameMap inputs_;
-  VariableNameMap outputs_;
-  AttributeMap attrs_;
-};
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/operator.h

@@ -18,17 +18,19 @@ limitations under the License. */
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "common/type_define.h"
 #include "common/types.h"
 #include "common/variant.h"
-#include "framework/attribute.h"
-#include "framework/block_desc.h"
-#include "framework/op_info.h"
-#include "framework/op_kernel_type.h"
-#include "framework/paddle_mobile_object.h"
 #include "framework/scope.h"
 #include "framework/tensor.h"
+#include "framework/op_info.h"
 #include "framework/variable.h"
+#include "framework/attribute.h"
+#include "framework/op_kernel_type.h"
+#include "framework/program/block_desc.h"
+#include "framework/paddle_mobile_object.h"
+#include "framework/program/program-optimize/node.h"
 
 namespace paddle_mobile {
 namespace framework {
@@ -102,5 +104,30 @@ class OpKernelBase : PaddleMobileObject {
       std::shared_ptr<::paddle_mobile::framework::Scope> scope)                \
       : parent_cls<Dtype, T>(type, inputs, outputs, attrs, scope) {}
 
+class FusionOpMatcher: PaddleMobileObject{
+ public:
+  FusionOpMatcher() {}
+
+  virtual std::string Type() = 0;
+
+  virtual void FolderNodes(Node &node) {
+    node.Folder(node_.Depth(), Type(), {});
+
+  }
+
+  virtual Node &BeginNode() {
+    return node_;
+  }
+
+  std::string BeginType() {
+    return node_.BeginType();
+  }
+
+ protected:
+  Node node_;
+  std::string type_;
+  std::shared_ptr<OpDesc> new_opdesc_;
+};
+
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/paddle_mobile_object.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #include "paddle_mobile_object.h"

src/framework/paddle_mobile_object.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
 #include <string>

src/framework/program-optimize/node.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#include <sstream>
-
-#include "node.h"
-
-namespace paddle_mobile {
-
-namespace framework {
-
-Node &Node::operator>(std::shared_ptr<Node> node) {
-  outputs_.push_back(node);
-  std::shared_ptr<Node> this_node;
-  node->inputs_.push_back(this);
-  return *node;
-}
-
-bool Node::operator==(const Node &in) {
-  if (in.type_ == this->type_) {
-    if (this->outputs_.size() == in.outputs_.size()) {
-      for (int i = 0; i < outputs_.size(); ++i) {
-        if (!(*outputs_[i] == *in.outputs_[i])) {
-          return false;
-        }
-      }
-    } else {
-      return false;
-    }
-  } else {
-    return false;
-  }
-  return true;
-}
-
-std::string Node::ToString(std::string blank, const Node *node) const {
-  std::stringstream ss;
-  ss << type_ << "-> \n";
-
-  if (inputs_.size() > 1 && node != inputs_.back()) {
-    return ss.str();
-  } else if (inputs_.size() > 1 && node == inputs_.back()) {
-    ss << "\n" << blank << type_ << "\n";
-  }
-
-  for (int i = 0; i < outputs_.size(); ++i) {
-    ss << blank << outputs_[i]->ToString(blank + " ", this) << "";
-  }
-  return ss.str();
-}
-
-std::string Node::ToString() const { return this->ToString(" ", this); }
-
-Node &Node::To(int index) {
-  if (index == 0) {
-    this->outputs_.clear();
-  }
-
-  for (int j = 0; j < this->outputs_.size(); ++j) {
-    outputs_[j]->To(index - 1);
-  }
-  return *this;
-}
-
-uint Node::depth(uint begin) {
-  uint depth = 0;
-  begin++;
-  for (int i = 0; i < outputs_.size(); ++i) {
-    uint output_depth = outputs_[i]->depth(begin);
-    depth = output_depth > depth ? output_depth : depth;
-  }
-  return begin > depth ? begin : depth;
-}
-
-Print &operator<<(Print &printer, const Node &node) {
-  printer << node.ToString();
-  return printer;
-}
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/program.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-namespace paddle_mobile {
-namespace framework {}
-}  // namespace paddle_mobile

src/framework/program.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#pragma once
-
-#include "common/types.h"
-#include "paddle_mobile_object.h"
-#include "program_desc.h"
-#include "scope.h"
-
-namespace paddle_mobile {
-namespace framework {
-
-template <typename Dtype, Precision P = Precision::FP32>
-class Program : PaddleMobileObject {
- public:
-  std::shared_ptr<ProgramDesc> originProgram;
-  std::shared_ptr<ProgramDesc> optimizeProgram;
-  std::shared_ptr<Scope> scope;
-
- private:
-};
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/block_desc.cpp → src/framework/program/block_desc.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #include "block_desc.h"
 
 namespace paddle_mobile {
@@ -37,11 +19,12 @@ std::vector<std::shared_ptr<OpDesc>> BlockDesc::Ops() const {
   return res;
 }
 
-BlockDesc::BlockDesc(const proto::BlockDesc &desc) : desc_(desc) {
-  for (const proto::VarDesc &var_desc : desc_.vars()) {
+BlockDesc::BlockDesc(const proto::BlockDesc &desc):
+        index_(desc.idx()), parent_index_(desc.parent_idx()) {
+  for (const proto::VarDesc &var_desc : desc.vars()) {
     vars_[var_desc.name()].reset(new VarDesc(var_desc));
   }
-  for (const proto::OpDesc &op_desc : desc_.ops()) {
+  for (const proto::OpDesc &op_desc : desc.ops()) {
     ops_.emplace_back(new framework::OpDesc(op_desc));
   }
 }

src/framework/block_desc.h → src/framework/program/block_desc.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
-#include "framework.pb.h"
-#include "op_desc.h"
-#include "paddle_mobile_object.h"
-#include "var_desc.h"
+#include "framework/framework.pb.h"
+#include "framework/program/op_desc.h"
+#include "framework/program/var_desc.h"
+#include "framework/paddle_mobile_object.h"
+
 
 namespace paddle_mobile {
 namespace framework {
 
 class BlockDesc : PaddleMobileObject {
  public:
+  friend class Node;
+  friend class ProgramOptimize;
   BlockDesc(const proto::BlockDesc &desc);
 
-  const int &ID() const { return desc_.idx(); }
+  BlockDesc(const BlockDesc &block_desc):
+          index_(block_desc.index_),
+          parent_index_(block_desc.parent_index_) {
+    for (auto &op_desc : block_desc.ops_) {
+      std::shared_ptr<OpDesc> copy_op_desc = std::make_shared<OpDesc>(*op_desc);
+      ops_.push_back(copy_op_desc);
+    }
+
+    for (auto &var_desc : block_desc.vars_) {
+      std::shared_ptr<VarDesc> copy_var_desc =
+              std::make_shared<VarDesc>(*var_desc.second);
+      vars_[var_desc.first] = copy_var_desc;
+    }
+  }
+
+  const int &ID() const { return index_; }
 
-  const int &Parent() const { return desc_.parent_idx(); }
+  const int &Parent() const { return parent_index_; }
 
   bool operator==(const paddle_mobile::framework::BlockDesc &in_block) const {
     return this->ID() == in_block.ID() && this->Parent() == in_block.Parent();
@@ -46,7 +46,8 @@ class BlockDesc : PaddleMobileObject {
   std::vector<std::shared_ptr<OpDesc>> Ops() const;
 
  private:
-  proto::BlockDesc desc_;
+  int index_;
+  int parent_index_;
   std::vector<std::shared_ptr<OpDesc>> ops_;
   std::unordered_map<std::string, std::shared_ptr<VarDesc>> vars_;
 };

src/framework/op_desc.cpp → src/framework/program/op_desc.cpp

@@ -12,19 +12,17 @@ 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. */
 
-//
-// Created by liuRuiLong on 2018/5/4.
-//
-#include "framework/op_desc.h"
 #include <string>
 #include <vector>
 
+#include "framework/program/op_desc.h"
+
 namespace paddle_mobile {
 namespace framework {
 
-OpDesc::OpDesc(const proto::OpDesc &desc) : desc_(desc) {
-  for (int i = 0; i < desc_.inputs_size(); ++i) {
-    const proto::OpDesc::Var &var = desc_.inputs(i);
+OpDesc::OpDesc(const proto::OpDesc &desc):type_(desc.type()) {
+  for (int i = 0; i < desc.inputs_size(); ++i) {
+    const proto::OpDesc::Var &var = desc.inputs(i);
     std::vector<std::string> &args = inputs_[var.parameter()];
     int arg_size = var.arguments_size();
     for (int j = 0; j < arg_size; ++j) {
@@ -32,8 +30,8 @@ OpDesc::OpDesc(const proto::OpDesc &desc) : desc_(desc) {
     }
   }
 
-  for (int i = 0; i < desc_.outputs_size(); ++i) {
-    const proto::OpDesc::Var &var = desc_.outputs(i);
+  for (int i = 0; i < desc.outputs_size(); ++i) {
+    const proto::OpDesc::Var &var = desc.outputs(i);
     std::vector<std::string> &args = outputs_[var.parameter()];
     int arg_size = var.arguments_size();
     for (int j = 0; j < arg_size; ++j) {
@@ -41,7 +39,7 @@ OpDesc::OpDesc(const proto::OpDesc &desc) : desc_(desc) {
     }
   }
 
-  for (const proto::OpDesc::Attr &attr : desc_.attrs()) {
+  for (const proto::OpDesc::Attr &attr : desc.attrs()) {
     std::string attr_name = attr.name();
     if (attr.type() != proto::AttrType::BLOCK) {
       attrs_[attr_name] = Attribute::GetAttrValue(attr);
@@ -62,9 +60,28 @@ Attribute OpDesc::GetAttr(const std::string &name) const {
   return it->second;
 }
 
-const std::unordered_map<std::string, Attribute> &OpDesc::GetAttrMap() const {
+std::unordered_map<std::string, Attribute> &OpDesc::GetAttrMap() {
   return attrs_;
 }
 
+Print &operator<<(Print &printer, const OpDesc &op_desc) {
+  OpDesc &no_const_op_desc =  const_cast<OpDesc &>(op_desc);
+  printer << "inputs: \n";
+  for (const auto &input : no_const_op_desc.GetInputs()) {
+    printer << input.first << " : " << input.second << "\n";
+  }
+
+  printer << "outputs: \n";
+  for (const auto &output : no_const_op_desc.GetOutputs()) {
+    printer << output.first << " : " << output.second << "\n";
+  }
+
+  printer << "outputs: \n";
+  for (const auto &attr : no_const_op_desc.GetAttrMap()) {
+    printer << attr.first << " : " << attr.second << "\n";
+  }
+  return printer;
+}
+
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/program/op_desc.h

+#pragma once
+
+#include <vector>
+#include <string>
+
+#include "common/log.h"
+#include "common/type_define.h"
+#include "framework/framework.pb.h"
+#include "framework/paddle_mobile_object.h"
+
+namespace paddle_mobile {
+namespace framework {
+
+class OpDesc : PaddleMobileObject {
+ public:
+  friend class ProgramOptimize;
+  friend class FusionOpMatcher;
+  friend class Node;
+  explicit OpDesc(const proto::OpDesc &desc);
+
+  OpDesc(const OpDesc &op_desc): type_(op_desc.type_) {
+    this->inputs_ = op_desc.inputs_;
+    this->outputs_ = op_desc.outputs_;
+    this->attrs_ = op_desc.attrs_;
+  }
+
+  OpDesc() {
+  }
+  const std::vector<std::string> &Input(const std::string &name) const;
+  const std::vector<std::string> &Output(const std::string &name) const;
+  Attribute GetAttr(const std::string &name) const;
+
+  VariableNameMap &GetInputs() { return inputs_; }
+
+  VariableNameMap &GetOutputs() { return outputs_; }
+
+  AttributeMap &GetAttrMap();
+
+  const std::string &Type() { return type_; }
+
+  void SetInputs(VariableNameMap inputs){
+    inputs_ = inputs;
+  }
+
+  void SetOutputs(VariableNameMap outputs){
+    outputs_ = outputs;
+  }
+
+  void SetAttrMap(AttributeMap attrs){
+    attrs_ = attrs;
+  }
+
+ private:
+  std::string type_;
+  VariableNameMap inputs_;
+  VariableNameMap outputs_;
+  AttributeMap attrs_;
+};
+
+Print &operator<<(Print &printer, const OpDesc &op_desc);
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program/program-optimize/fusion_op_register.cpp

+#include "fusion_op_register.h"

src/framework/program/program-optimize/fusion_op_register.h

+#pragma once
+
+#include <map>
+#include <string>
+
+#include "framework/operator.h"
+#include "node.h"
+
+namespace paddle_mobile {
+namespace framework {
+
+class FusionOpRegister {
+ public:
+  static FusionOpRegister *Instance() {
+    static FusionOpRegister *regist = nullptr;
+    if (regist == nullptr) {
+      regist = new FusionOpRegister();
+    }
+    return regist;
+  }
+
+  void regist(FusionOpMatcher* matcher) {
+    std::shared_ptr<FusionOpMatcher> shared_matcher(matcher);
+    matchers_[matcher->Type()] = shared_matcher;
+  }
+
+  const std::map<std::string, std::shared_ptr<FusionOpMatcher>> Matchers() {
+    return matchers_;
+  }
+
+ private:
+  std::map<std::string, std::shared_ptr<FusionOpMatcher>> matchers_;
+  FusionOpRegister() {}
+};
+
+class FusionOpRegistrar{
+ public:
+  explicit FusionOpRegistrar(FusionOpMatcher* matcher){
+    FusionOpRegister::Instance()->regist(matcher);
+  }
+};
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program/program-optimize/node.cpp

+#include <sstream>
+
+#include "framework/program/program-optimize/node.h"
+
+namespace paddle_mobile {
+
+namespace framework {
+
+Node &Node::operator>(std::shared_ptr<Node> node) {
+  outputs_.push_back(node);
+  std::shared_ptr<Node> this_node;
+  node->inputs_.push_back(this);
+  return *node;
+}
+
+bool Node::operator==(const Node &in) {
+  if (in.type_ == this->type_) {
+    if (this->outputs_.size() == in.outputs_.size()) {
+      for (int i = 0; i < outputs_.size(); ++i) {
+        if (!(*outputs_[i] == *in.outputs_[i])) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  return true;
+}
+
+// std::shared_ptr<Node> Node::MatchTheFirstNode(std::string type){
+//
+//  for (const auto &node : outputs_){
+//    if (node->type_ == type){
+//      return node;
+//    }else{
+//
+//    }
+//  }
+//}
+
+std::vector<std::shared_ptr<framework::OpDesc>> Node::OpDescs(uint size) {
+  std::vector<std::shared_ptr<framework::OpDesc>> op_descs;
+  OpDescs(size - 1, &op_descs);
+  return op_descs;
+}
+
+void Node::OpDescs(uint index,
+                   std::vector<std::shared_ptr<framework::OpDesc>> *op_desc) {
+  if (index == 0) {
+    return;
+  }
+  op_desc->push_back(this->op_desc_);
+  for (auto &output : outputs_) {
+    output->OpDescs(index, op_desc);
+  }
+}
+
+void Node::OpDescs(std::vector<std::shared_ptr<framework::OpDesc>> *op_desc, Node *node) {
+  auto iter = std::find(op_desc->begin(), op_desc->end(), this->op_desc_);
+  if (inputs_.size() > 1 && node != inputs_.back()) {
+    return;
+  } else if (inputs_.size() > 1 && node == inputs_.back()) {
+    op_desc->push_back(this->op_desc_);
+  } else {
+    op_desc->push_back(this->op_desc_);
+  }
+
+  for (auto &output : outputs_) {
+    output->OpDescs(op_desc, this);
+  }
+}
+
+std::vector<std::shared_ptr<framework::OpDesc>> Node::OpDescs() {
+  std::vector<std::shared_ptr<framework::OpDesc>> op_descs;
+  OpDescs(&op_descs, this);
+  return op_descs;
+}
+
+std::string Node::ToString(std::string blank, const Node *node) const {
+  std::stringstream ss;
+  ss << type_ << "-> \n";
+
+  if (inputs_.size() > 1 && node != inputs_.back()) {
+    return ss.str();
+  } else if (inputs_.size() > 1 && node == inputs_.back()) {
+    ss << "\n" << blank << type_ << "\n";
+  }
+
+  for (int i = 0; i < outputs_.size(); ++i) {
+    ss << blank << outputs_[i]->ToString(blank + "  ", this) << "";
+  }
+  return ss.str();
+}
+
+std::string Node::ToString() const { return this->ToString("  ", this); }
+
+std::shared_ptr<Node> Node::To(int size) {
+  std::shared_ptr<Node> node = std::make_shared<Node>();
+  this->To(size - 1, node);
+  return node;
+}
+
+// Node &Node::To(int size) {
+//  if (size == 1) {
+//    this->outputs_.clear();
+//  }
+//
+//  for (int j = 0; j < this->outputs_.size(); ++j) {
+//    outputs_[j]->To(size - 1);
+//  }
+//  return *this;
+//}
+
+void Node::To(int index, std::shared_ptr<Node> node) {
+  node->type_ = this->type_;
+  if (index != 0) {
+  } else {
+    return;
+  }
+
+  for (int j = 0; j < this->outputs_.size(); ++j) {
+    std::shared_ptr<Node> sub_node = std::make_shared<Node>();
+    node->outputs_.push_back(sub_node);
+    outputs_[j]->To(index - 1, sub_node);
+  }
+}
+
+uint Node::Depth(uint begin) {
+  uint depth = 0;
+  begin++;
+  for (int i = 0; i < outputs_.size(); ++i) {
+    uint output_depth = outputs_[i]->Depth(begin);
+    depth = output_depth > depth ? output_depth : depth;
+  }
+  return begin > depth ? begin : depth;
+}
+
+Node &Node::Folder(
+    uint size, std::string type,
+    std::map<std::string, std::pair<std::string, std::string>> change) {
+  std::shared_ptr<framework::OpDesc> op_desc =
+      std::make_shared<framework::OpDesc>();
+  op_desc->inputs_ = this->op_desc_->inputs_;
+  std::vector<std::shared_ptr<Node>> outputs;
+  this->Folder(op_desc, &outputs, size - 1, &change, this);
+  this->outputs_ = outputs;
+  this->type_ = type;
+  this->op_desc_ = op_desc;
+  this->op_desc_->type_ = type;
+  return *this;
+}
+
+void Node::Folder(
+    std::shared_ptr<framework::OpDesc> op_desc,
+    std::vector<std::shared_ptr<Node>> *outputs, uint index,
+    std::map<std::string, std::pair<std::string, std::string>> *change,
+    Node *begin_node) {
+  if (change->find(this->type_) != change->end()) {
+    auto change_pair = (*change)[this->type_];
+    op_desc->GetInputs()[change_pair.second] =
+        this->op_desc_->GetInputs()[change_pair.first];
+  }
+
+  for (auto &attr_pair : this->op_desc_->attrs_) {
+    op_desc->attrs_.emplace(attr_pair.first, attr_pair.second);
+  }
+  if (index > 0) {
+    --index;
+    for (auto output : outputs_) {
+      output->Folder(op_desc, outputs, index, change, begin_node);
+    }
+  } else {
+    for (auto &op_output : this->op_desc_->outputs_) {
+      op_desc->outputs_.emplace(op_output.first, op_output.second);
+    }
+
+    for (auto &output : this->outputs_) {
+      auto iter =
+          std::find(output->inputs_.begin(), output->inputs_.end(), this);
+
+      if (iter != output->inputs_.end()) {
+        output->inputs_.erase(iter);
+      }
+      output->inputs_.push_back(begin_node);
+      outputs->push_back(output);
+    }
+  }
+}
+
+void Node::Description() {
+  if (op_desc_.get()) {
+    DLOG << *op_desc_;
+  } else {
+    DLOG << " null ";
+  }
+}
+
+Print &operator<<(Print &printer, const Node &node) {
+  printer << node.ToString();
+  return printer;
+}
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program-optimize/node.h → src/framework/program/program-optimize/node.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
+#include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "common/log.h"
-#include "framework/op_desc.h"
+#include "framework/program/op_desc.h"
 #include "framework/paddle_mobile_object.h"
 
 namespace paddle_mobile {
@@ -30,17 +14,35 @@ namespace framework {
 
 class Node : PaddleMobileObject {
  public:
-  Node(const std::string &type) : type_(type) {}
-  Node(std::shared_ptr<OpDesc> op_desc)
-      : op_desc_(op_desc), type_(op_desc->Type()){};
+  Node() {}
+  explicit Node(const std::string &type) : type_(type) {}
+  explicit Node(std::shared_ptr<OpDesc> op_desc)
+      : op_desc_(op_desc), type_(op_desc->Type()) {}
   Node &operator>(std::shared_ptr<Node> node);
   bool operator==(const Node &in);
   std::string ToString() const;
-  Node &To(int index);
-  uint depth(uint begin = 0);
+  std::shared_ptr<Node> To(int size);
+  uint Depth(uint begin = 0);
+  Node &Folder(
+      uint size, std::string type,
+      std::map<std::string, std::pair<std::string, std::string>> change_map);
+  std::vector<std::shared_ptr<framework::OpDesc>> OpDescs(uint size);
+  std::vector<std::shared_ptr<framework::OpDesc>> OpDescs();
+  void OpDescs(std::vector<std::shared_ptr<framework::OpDesc>> *op_desc,  Node *node);
+  std::shared_ptr<framework::OpDesc> OpDesc() { return op_desc_; }
+  std::string BeginType() { return type_; }
+  void Description();
 
  private:
-  std::shared_ptr<OpDesc> op_desc_;
+  void OpDescs(uint size,
+               std::vector<std::shared_ptr<framework::OpDesc>> *op_desc);
+  void To(int index, std::shared_ptr<Node>);
+  void Folder(
+      std::shared_ptr<framework::OpDesc> op_desc,
+      std::vector<std::shared_ptr<Node>> *outputs, uint index,
+      std::map<std::string, std::pair<std::string, std::string>> *change,
+      Node *begin_node);
+  std::shared_ptr<framework::OpDesc> op_desc_;
   std::string ToString(std::string blank, const Node *node) const;
   std::vector<std::shared_ptr<Node>> outputs_;
   std::vector<Node *> inputs_;

src/framework/program-optimize/program_optimize.cpp → src/framework/program/program-optimize/program_optimize.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#include "program_optimize.h"
+#include "framework/program/program-optimize/program_optimize.h"
+#include "framework/program/program-optimize/fusion_op_register.h"
 
 namespace paddle_mobile {
 
@@ -26,20 +9,30 @@ std::shared_ptr<ProgramDesc> ProgramOptimize::Optimize() {}
 
 std::shared_ptr<ProgramDesc> ProgramOptimize::FushionOptimize(
     std::shared_ptr<ProgramDesc> ori_des) {
-  for (int i = 0; i < ori_des->Blocks().size(); ++i) {
+
+  ProgramDesc *optimize_program = new ProgramDesc(*ori_des);
+
+  for (int i = 0; i < optimize_program->Blocks().size(); ++i) {
     std::unordered_map<std::string, std::shared_ptr<Node>> output_nodes;
+    std::unordered_map<std::string, std::vector<std::shared_ptr<Node>>>
+        type_map;
+
     std::shared_ptr<Node> begin_node;
-    auto block = ori_des->Block(i);
+    auto block = optimize_program->Block(i);
     //        DLOG << " ops size: " << block->Ops().size();
     for (int j = 0; j < block->Ops().size(); ++j) {
       auto op = block->Ops()[j];
       auto op_type = op->Type();
-      //            DLOG << "op type: " << op_type << " index: " << j;
       if (op_input_output_key.find(op->Type()) == op_input_output_key.end()) {
-        return NULL;
+        LOG(kLOG_ERROR) << "return null ";
+        return nullptr;
       }
 
       std::shared_ptr<Node> node = std::make_shared<Node>(op);
+
+      //
+      type_map[op->Type()].push_back(node);
+
       if (j == 0) {
         begin_node = node;
       }
@@ -65,9 +58,36 @@ std::shared_ptr<ProgramDesc> ProgramOptimize::FushionOptimize(
       }
     }
 
-    DLOG << "node: \n" << *begin_node;
+    for (auto &registed : FusionOpRegister::Instance()->Matchers()) {
+      std::string fusion_type = registed.first;
+      std::shared_ptr<FusionOpMatcher> matcher = registed.second;
+      //      DLOG << " registed node \n " << matcher->BeginNode();
+
+      auto match_vector = type_map[matcher->BeginType()];
+
+      for (auto &match_node : match_vector) {
+        auto depth = matcher->BeginNode().Depth();
+        auto sub_node = match_node->To(depth);
+        //        DLOG << " sub node: " << *sub_node;
+        if (*sub_node == matcher->BeginNode()) {
+          //          DLOG << " match success " << " fusion node: \n" <<
+          //          matcher->BeginNode() << "\nsub node: \n" << *sub_node;
+          //          DLOG << "match node\n"<< *match_node;
+          matcher->FolderNodes(*match_node);
+          //          DLOG << " after match node\n"<< *match_node;
+          //          match_node->Description();
+
+          //          DLOG << "begin node: \n" << *begin_node;
+        }
+      }
+    }
+
+//    DLOG << "node: \n" << *begin_node;
+    block->ops_ = begin_node->OpDescs();
+
   }
-  return ori_des;
+  std::shared_ptr<ProgramDesc> shared_optimzie(optimize_program);
+  return shared_optimzie;
 }
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/program-optimize/program_optimize.h → src/framework/program/program-optimize/program_optimize.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
+#include <string>
+#include <vector>
+
 #include "framework/operator.h"
-#include "framework/program_desc.h"
+#include "framework/program/program_desc.h"
 #include "node.h"
 
 namespace paddle_mobile {
@@ -31,7 +16,6 @@ class ProgramOptimize {
   std::shared_ptr<ProgramDesc> Optimize();
   std::shared_ptr<ProgramDesc> FushionOptimize(
       std::shared_ptr<ProgramDesc> ori_des);
-
  private:
   //                std::shared_ptr<ProgramDesc> ori_desc_;
   std::vector<std::unordered_map<std::string, std::shared_ptr<Node>>>

src/framework/program/program.cpp

+namespace paddle_mobile {
+namespace framework {}
+}  // namespace paddle_mobile

src/framework/program/program.h

+#pragma once
+
+#include "common/types.h"
+#include "framework/paddle_mobile_object.h"
+#include "framework/program/program_desc.h"
+#include "framework/scope.h"
+
+namespace paddle_mobile {
+namespace framework {
+
+template <typename Dtype, Precision P = Precision::FP32>
+class Program : PaddleMobileObject {
+ public:
+  std::shared_ptr<ProgramDesc> originProgram;
+  std::shared_ptr<ProgramDesc> optimizeProgram;
+  std::shared_ptr<Scope> scope;
+
+ private:
+};
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program/program_desc.cpp

+#include <vector>
+#include <string>
+
+#include "program_desc.h"
+
+namespace paddle_mobile {
+namespace framework {
+
+ProgramDesc::ProgramDesc(const proto::ProgramDesc &desc) {
+  for (auto &block_desc : desc.blocks()) {
+    // new framework::BlockDesc(block_desc)
+    blocks_.emplace_back(std::make_shared<BlockDesc>(block_desc));
+  }
+}
+
+void ProgramDesc::Description(std::string header) {
+#ifdef PADDLE_MOBILE_DEBUG
+  if (header.size()){
+    LOG(kLOG_INFO) << header;
+  }
+  for (const auto &block : this->blocks_) {
+    LOG(kLOG_DEBUG) << "block: " << block->ID();
+    LOG(kLOG_INFO) << "block ops size: " << block->Ops().size();
+    for (int j = 0; j < block->Ops().size(); ++j) {
+      const auto &op = block->Ops()[j];
+      LOG(kLOG_DEBUG1) << "op: " << op->Type();
+      for (auto &input : op->GetInputs()) {
+        LOG(kLOG_DEBUG2) << "input parameter: " << input.first;
+        for (auto &n : input.second) {
+          LOG(kLOG_DEBUG3) << "argument - " << n;
+        }
+      }
+      for (auto &output : op->GetOutputs()) {
+        LOG(kLOG_DEBUG2) << "output parameter: " << output.first;
+        for (auto &n : output.second) {
+          LOG(kLOG_DEBUG3) << "argument - " << n;
+        }
+      }
+      for (auto &attr : op->GetAttrMap()) {
+        LOG(kLOG_DEBUG2) << "attr name:: " << attr.first;
+        LOG(kLOG_DEBUG3) << "argument - " << attr.second;
+      }
+    }
+  }
+#endif
+}
+
+std::shared_ptr<BlockDesc> ProgramDesc::Block(size_t idx) {
+  return blocks_[idx];
+}
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program/program_desc.h

+#pragma once
+
+#include <vector>
+
+#include "common/types.h"
+#include "framework/program/block_desc.h"
+#include "framework/paddle_mobile_object.h"
+
+namespace paddle_mobile {
+namespace framework {
+
+class ProgramDesc : PaddleMobileObject {
+ public:
+  friend class Node;
+  friend class ProgramOptimize;
+  explicit ProgramDesc(const proto::ProgramDesc &desc);
+  std::shared_ptr<BlockDesc> Block(size_t idx);
+  const std::vector<std::shared_ptr<BlockDesc>> &Blocks() { return blocks_; }
+  ProgramDesc(const ProgramDesc &program_desc) {
+    for (auto &block : program_desc.blocks_) {
+      std::shared_ptr<BlockDesc> copy_block =
+              std::make_shared<BlockDesc>(*block);
+      blocks_.push_back(copy_block);
+    }
+  }
+
+  void Description(std::string header = "");
+ private:
+  std::vector<std::shared_ptr<BlockDesc>> blocks_;
+};
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/program/var_desc.cpp

+#include "var_desc.h"
+
+namespace paddle_mobile {
+
+namespace framework {
+
+VarDesc::VarDesc(const proto::VarDesc &desc) : desc_(desc) {}
+
+}  // namespace framework
+}  // namespace paddle_mobile

src/framework/var_desc.h → src/framework/program/var_desc.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
-#include "framework.pb.h"
-#include "paddle_mobile_object.h"
+#include "framework/framework.pb.h"
+#include "framework/paddle_mobile_object.h"
 
 namespace paddle_mobile {
 namespace framework {
@@ -28,6 +10,8 @@ class VarDesc {
  public:
   VarDesc(const proto::VarDesc &desc);
 
+  VarDesc(const VarDesc &var_desc):desc_(var_desc.desc_) {}
+
   std::string Name() const { return desc_.name(); }
 
   proto::VarType::Type GetType() const { return desc_.type().type(); }

src/framework/program_desc.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. */
-
-//
-// Created by liuRuiLong on 2018/5/4.
-//
-
-#include "framework/program_desc.h"
-
-namespace paddle_mobile {
-namespace framework {
-
-ProgramDesc::ProgramDesc(const proto::ProgramDesc &desc) : desc_(desc) {
-  for (auto &block_desc : *desc_.mutable_blocks()) {
-    // new framework::BlockDesc(block_desc)
-    blocks_.emplace_back(std::make_shared<BlockDesc>(block_desc));
-  }
-}
-
-std::shared_ptr<BlockDesc> ProgramDesc::Block(size_t idx) {
-  return blocks_[idx];
-}
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/program_desc.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#pragma once
-
-#include <vector>
-
-#include "block_desc.h"
-#include "common/types.h"
-#include "paddle_mobile_object.h"
-
-namespace paddle_mobile {
-namespace framework {
-
-class ProgramDesc : PaddleMobileObject {
- public:
-  ProgramDesc(const proto::ProgramDesc &desc);
-  std::shared_ptr<BlockDesc> Block(size_t idx);
-  const std::vector<std::shared_ptr<BlockDesc>> &Blocks() { return blocks_; };
-
- private:
-  std::vector<std::shared_ptr<BlockDesc>> blocks_;
-  proto::ProgramDesc desc_;
-};
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/scope.h

-
-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
 #pragma once
 
 #include <list>           //std::list

src/framework/selected_rows.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 
 #include <vector>

src/framework/var_desc.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
-#include "var_desc.h"
-
-namespace paddle_mobile {
-
-namespace framework {
-
-VarDesc::VarDesc(const proto::VarDesc &desc) : desc_(desc) {}
-
-}  // namespace framework
-}  // namespace paddle_mobile

src/framework/var_type.h

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
-
 #pragma once
 #include "framework.pb.h"
 #include "lod_tensor.h"

src/framework/variable.h

-
-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
 #pragma once
 
 #include <iostream>

src/io.cpp

@@ -14,14 +14,14 @@ limitations under the License. */
 
 #include <fstream>
 
-#include "../src/io.h"
+#include "io.h"
 #include "common/log.h"
-#include "framework/framework.pb.h"
-#include "framework/lod_tensor.h"
-#include "framework/program_desc.h"
 #include "framework/scope.h"
 #include "framework/tensor.h"
-#define PADDLE_MOBILE_DEBUG 1
+#include "framework/lod_tensor.h"
+#include "framework/framework.pb.h"
+#include "framework/program/program_desc.h"
+
 namespace paddle_mobile {
 
 void ReadBinaryFile(const std::string &filename, std::string *contents) {
@@ -152,7 +152,7 @@ const framework::Program<Dtype, P> Loader<Dtype, P>::Load(
           LoadVar(tensor, dirname + "/" + var_desc->Name());
         }
       } else {
-        //  TODO by someone
+        // TODO(codeWorm): some.
       }
     }
   }
@@ -303,7 +303,7 @@ const framework::Program<Dtype, P> Loader<Dtype, P>::Load(
         is.read(static_cast<char *>(memory), memory_size * type_size);
         is.close();
       } else {
-        //  TODO
+        // TODO
       }
     }
   }

src/io.h

@@ -19,7 +19,7 @@ limitations under the License. */
 #include "common/types.h"
 #include "framework/lod_tensor.h"
 #include "framework/paddle_mobile_object.h"
-#include "framework/program.h"
+#include "framework/program/program.h"
 
 namespace paddle_mobile {
 

src/operators/fusion_conv_add_relu_op.cpp

+#include "fusion_conv_add_relu_op.h"

src/operators/fusion_conv_add_relu_op.h

+#pragma once
+
+#include "framework/operator.h"
+#include "framework/program/program-optimize/fusion_op_register.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+class FushionConvAddReluOpMatcher : public framework::FusionOpMatcher {
+ public:
+  FushionConvAddReluOpMatcher() {
+    node_ = framework::Node("conv2d");
+    node_ > std::make_shared<framework::Node>("elementwise_add") > std::make_shared<framework::Node>("relu");
+  }
+
+  void FolderNodes(framework::Node &node) {
+    std::vector<std::shared_ptr<framework::OpDesc>> origin_descs = node.OpDescs(node_.Depth());
+    node.Folder(node_.Depth(), Type(), {{"elementwise_add" , {"Y", "Z"}}});
+  }
+
+  std::string Type() {
+    return "FusionConvAddRelu";
+  }
+};
+
+class FusionFcOp {
+ public:
+ private:
+};
+
+static framework::FusionOpRegistrar fc_registrar(new FushionConvAddReluOpMatcher());
+
+}
+}

src/operators/fusion_fc_op.cpp

+#include "fusion_fc_op.h"
\ No newline at end of file

src/operators/fusion_fc_op.h

+#pragma once
+
+#include <string>
+
+#include "framework/operator.h"
+#include "framework/program/program-optimize/fusion_op_register.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+class FusionFcMatcher : public framework::FusionOpMatcher {
+ public:
+  FusionFcMatcher() {
+    node_ = framework::Node("mul");
+    node_ > std::make_shared<framework::Node>("elementwise_add");
+  }
+
+  void FolderNodes(framework::Node &node) {
+    std::vector<std::shared_ptr<framework::OpDesc>> origin_descs = node.OpDescs(node_.Depth());
+    node.Folder(node_.Depth(), Type(), {{"elementwise_add" , {"Y", "Z"}}});
+  }
+
+  std::string Type() {
+    return "fc";
+  }
+};
+
+class FusionFcOp {
+ public:
+ private:
+};
+
+static framework::FusionOpRegistrar fc_registrar(new FusionFcMatcher());
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/platform/data_type.h

-/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
+/* 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.

test/common/test_log.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 "common/log.h"
 
 int main() {

test/framework/test_load.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
+/* 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 "io.h"
 

test/framework/test_optimize.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
 
-#include "framework/program-optimize/node.h"
-#include "framework/program-optimize/program_optimize.h"
+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 "framework/program/program-optimize/node.h"
+#include "framework/program/program-optimize/program_optimize.h"
 #include "io.h"
 
 using namespace paddle_mobile;
@@ -28,13 +24,13 @@ int main() {
   Loader<paddle_mobile::CPU> loader;
   //    "../../../test/models/googlenet"
   auto program = loader.Load("../models/googlenet");
-
   ProgramOptimize optimize;
-
+//  program.originProgram->Description("origin");
   auto optimize_program = optimize.FushionOptimize(program.originProgram);
-  if (optimize_program) {
-
+  if (optimize_program != nullptr) {
+//    optimize_program->Description("optimize");
   } else {
-    DLOG << "optimize_program is null";
+    LOG(kLOG_ERROR) << "optimize_program is null";
   }
+  return 0;
 }

test/operators/test_cov_op.cpp

-/* Copyright (c) 2016 Baidu, Inc. All Rights Reserved.
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-==============================================================================*/
+/* 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 "../framework/executor_for_test.h"
 #include "../test_helper.h"
@@ -22,6 +18,7 @@ SOFTWARE.
 
 int main() {
   paddle_mobile::Loader<paddle_mobile::CPU> loader;
+  //../models/image_classification_resnet.inference.model
   auto program = loader.Load(std::string("../models/googlenet"));
   if (program.originProgram == nullptr) {
     DLOG << "program file read fail";

test/test_include.h

@@ -12,17 +12,18 @@ 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 "framework/block_desc.h"
+#include <map>
+#include <string>
+#include <vector>
+
+#include "framework/program/block_desc.h"
 #include "framework/framework.pb.h"
 #include "framework/lod_tensor.h"
 #include "framework/operator.h"
-#include "framework/program.h"
-#include "framework/program_desc.h"
+#include "framework/program/program.h"
+#include "framework/program/program_desc.h"
 #include "framework/scope.h"
 #include "framework/tensor.h"
 #include "framework/variable.h"
 #include "io.h"
 #include "test_helper.h"
-#include <map>
-#include <string>
-#include <vector>
\ No newline at end of file