split the desc apis, test=develop (#3782)

lite/model_parser/base/block_desc.h

+// Copyright (c) 2020 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 <cstdint>
+#include <string>
+#include <vector>
+
+namespace paddle {
+namespace lite {
+
+class BlockDescReadAPI {
+ public:
+  virtual int32_t Idx() const = 0;
+  virtual int32_t ParentIdx() const = 0;
+  virtual size_t VarsSize() const = 0;
+  virtual size_t OpsSize() const = 0;
+  virtual int32_t ForwardBlockIdx() const = 0;
+
+  template <typename T>
+  T* GetVar(int32_t idx);
+
+  template <typename T>
+  T const* GetVar(int32_t idx) const;
+
+  template <typename T>
+  T* GetOp(int32_t idx);
+
+  template <typename T>
+  T const* GetOp(int32_t idx) const;
+
+  virtual ~BlockDescReadAPI() = default;
+};
+
+class BlockDescWriteAPI {
+ public:
+  virtual void SetIdx(int32_t idx) = 0;
+  virtual void SetParentIdx(int32_t idx) = 0;
+  virtual void ClearVars() = 0;
+  virtual void ClearOps() = 0;
+  virtual void SetForwardBlockIdx(int32_t idx) = 0;
+
+  template <typename T>
+  T* AddVar();
+
+  template <typename T>
+  T* AddOp();
+
+  virtual ~BlockDescWriteAPI() = default;
+};
+
+// The reading and writing of the model are one-time and separate.
+// This interface is a combination of reading and writing interfaces,
+// which is used to support legacy interfaces.
+
+class BlockDescAPI : public BlockDescReadAPI, public BlockDescWriteAPI {
+ public:
+  virtual ~BlockDescAPI() = default;
+};
+
+}  // namespace lite
+}  // namespace paddle

lite/model_parser/base/op_desc.h

+// Copyright (c) 2020 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 <string>
+#include <vector>
+#include "lite/utils/string.h"
+
+namespace paddle {
+namespace lite {
+
+// The AttrType is used to make the proto::AttrType portable.
+enum class OpAttrType {
+  INT = 0,
+  FLOAT = 1,
+  STRING = 2,
+  INTS = 3,
+  FLOATS = 4,
+  STRINGS = 5,
+  BOOLEAN = 6,
+  BOOLEANS = 7,
+  BLOCK = 8,
+  LONG = 9,
+  BLOCKS = 10,
+  LONGS = 11,
+  UNK,
+};
+
+template <OpAttrType Type>
+struct OpAttrTypeTrait;
+
+template <typename T>
+struct OpDataTypeTrait;
+
+#define TYPE_TRAIT_IMPL(T, type__)                  \
+  template <>                                       \
+  struct OpAttrTypeTrait<OpAttrType::T> {           \
+    typedef type__ DT;                              \
+  };                                                \
+  template <>                                       \
+  struct OpDataTypeTrait<type__> {                  \
+    static constexpr OpAttrType AT = OpAttrType::T; \
+    static constexpr const char* ATN = #T;          \
+  };
+
+TYPE_TRAIT_IMPL(INT, int32_t);
+TYPE_TRAIT_IMPL(FLOAT, float);
+TYPE_TRAIT_IMPL(STRING, std::string);
+TYPE_TRAIT_IMPL(BOOLEAN, bool);
+TYPE_TRAIT_IMPL(LONG, int64_t);
+TYPE_TRAIT_IMPL(INTS, std::vector<int>);
+TYPE_TRAIT_IMPL(FLOATS, std::vector<float>);
+TYPE_TRAIT_IMPL(STRINGS, std::vector<std::string>);
+TYPE_TRAIT_IMPL(LONGS, std::vector<int64_t>);
+#undef TYPE_TRAIT_IMPL
+
+class OpDescReadAPI {
+ public:
+  virtual std::string Type() const = 0;
+  virtual std::vector<std::string> Input(const std::string& param) const = 0;
+  virtual std::vector<std::string> InputArgumentNames() const = 0;
+  virtual std::vector<std::string> Output(const std::string& param) const = 0;
+  virtual std::vector<std::string> OutputArgumentNames() const = 0;
+  virtual bool HasAttr(const std::string& name) const = 0;
+  virtual OpAttrType GetAttrType(const std::string& name) const = 0;
+  virtual std::vector<std::string> AttrNames() const = 0;
+
+  template <typename T>
+  T GetAttr(const std::string& name) const;
+
+  std::string Repr() const {
+    STL::stringstream ss;
+    ss << Type();
+    ss << "(";
+    for (auto& arg : InputArgumentNames()) {
+      ss << arg << ":";
+      for (auto val : Input(arg)) {
+        ss << val << " ";
+      }
+    }
+    ss << ") -> (";
+    for (auto& arg : OutputArgumentNames()) {
+      ss << arg << ":";
+      for (auto val : Output(arg)) {
+        ss << val << " ";
+      }
+    }
+    ss << ")";
+    return ss.str();
+  }
+
+  virtual ~OpDescReadAPI() = default;
+};
+
+class OpDescWriteAPI {
+ public:
+  virtual void SetType(const std::string& type) = 0;
+  virtual void SetInput(const std::string& param,
+                        const std::vector<std::string>& args) = 0;
+  virtual void SetOutput(const std::string& param,
+                         const std::vector<std::string>& args) = 0;
+
+  template <typename T>
+  void SetAttr(const std::string& name, const T& v);
+
+  virtual ~OpDescWriteAPI() = default;
+};
+
+// The reading and writing of the model are one-time and separate.
+// This interface is a combination of reading and writing interfaces,
+// which is used to support legacy interfaces.
+
+class OpDescAPI : public OpDescReadAPI, public OpDescWriteAPI {
+ public:
+  using AttrType = OpAttrType;
+  virtual ~OpDescAPI() = default;
+};
+
+}  // namespace lite
+}  // namespace paddle

lite/model_parser/base/program_desc.h

+// Copyright (c) 2020 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
+
+namespace paddle {
+namespace lite {
+
+class ProgramDescReadAPI {
+ public:
+  virtual size_t BlocksSize() const = 0;
+  virtual bool HasVersion() const = 0;
+  virtual int64_t Version() const = 0;
+
+  template <typename T>
+  T* GetBlock(int32_t idx);
+
+  template <typename T>
+  T const* GetBlock(int32_t idx) const;
+
+  virtual ~ProgramDescReadAPI() = default;
+};
+
+class ProgramDescWriteAPI {
+ public:
+  virtual void ClearBlocks() = 0;
+  virtual void SetVersion(int64_t version) = 0;
+
+  template <typename T>
+  T* AddBlock();
+
+  virtual ~ProgramDescWriteAPI() = default;
+};
+
+// The reading and writing of the model are one-time and separate.
+// This interface is a combination of reading and writing interfaces,
+// which is used to support legacy interfaces.
+
+class ProgramDescAPI : public ProgramDescReadAPI, public ProgramDescWriteAPI {
+ public:
+  virtual ~ProgramDescAPI() = default;
+};
+
+}  // namespace lite
+}  // namespace paddle

lite/model_parser/base/var_desc.h

+// Copyright (c) 2020 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 <string>
+#include <vector>
+
+namespace paddle {
+namespace lite {
+
+enum class VarDataType {
+  // Pod Types
+  BOOL = 0,
+  INT16,
+  INT32,
+  INT64,
+  FP16,
+  FP32,
+  FP64,
+  // Tensor<size_t> is used in C++.
+  SIZE_T,
+  UINT8,
+  INT8,
+
+  // Other types that may need additional descriptions
+  LOD_TENSOR,
+  SELECTED_ROWS,
+  FEED_MINIBATCH,
+  FETCH_LIST,
+  STEP_SCOPES,
+  LOD_RANK_TABLE,
+  LOD_TENSOR_ARRAY,
+  PLACE_LIST,
+  READER,
+  // Any runtime decided variable type is raw
+  // raw variables should manage their own allocations
+  // in operators like nccl_op
+  RAW,
+  TUPLE
+};
+
+class VarDescReadAPI {
+ public:
+  virtual std::string Name() const = 0;
+  virtual VarDataType GetType() const = 0;
+  virtual bool Persistable() const = 0;
+  virtual std::vector<int64_t> GetShape() const = 0;
+  virtual ~VarDescReadAPI() = default;
+};
+
+class VarDescWriteAPI {
+ public:
+  virtual void SetName(std::string name) = 0;
+  virtual void SetType(VarDataType type) = 0;
+  virtual void SetPersistable(bool persistable) = 0;
+  virtual void SetShape(const std::vector<int64_t>& dims) = 0;
+  virtual ~VarDescWriteAPI() = default;
+};
+
+// The reading and writing of the model are one-time and separate.
+// This interface is a combination of reading and writing interfaces,
+// which is used to support legacy interfaces.
+
+class VarDescAPI : public VarDescReadAPI, public VarDescWriteAPI {
+ public:
+  using VarDataType = lite::VarDataType;
+  using Type = lite::VarDataType;
+  virtual ~VarDescAPI() = default;
+};
+
+}  // namespace lite
+}  // namespace paddle

lite/model_parser/cpp/block_desc.h

@@ -47,6 +47,11 @@ class BlockDesc : public BlockDescAPI {
 
   std::vector<VarDesc>& GetVars() { return vars_; }
 
+  template <typename T>
+  T const* GetVar(int32_t idx) const {
+    return GetVar<T>(idx);
+  }
+
   template <typename T>
   T* AddVar();
 
@@ -57,6 +62,11 @@ class BlockDesc : public BlockDescAPI {
   template <typename T>
   T* GetOp(int32_t idx);
 
+  template <typename T>
+  T const* GetOp(int32_t idx) const {
+    return GetOp<T>(idx);
+  }
+
   template <typename T>
   T* AddOp();
 

lite/model_parser/cpp/op_desc.h

@@ -108,7 +108,7 @@ class OpDesc : public OpDescAPI {
 
   template <typename T>
   void SetAttr(const std::string& name, const T& v) {
-    attr_types_[name] = OpDescAPI::DataTypeTrait<T>::AT;
+    attr_types_[name] = OpDataTypeTrait<T>::AT;
     attrs_[name].set(v);
   }
 
@@ -119,8 +119,8 @@ class OpDesc : public OpDescAPI {
     auto attr_it = attr_types().find(name);
     CHECK(attr_it != attr_types().end());
     auto pair = std::make_pair(it, attr_it);
-    CHECK(pair.second->second == OpDescAPI::DataTypeTrait<T>::AT)
-        << "required type is " << OpDescAPI::DataTypeTrait<T>::ATN
+    CHECK(pair.second->second == OpDataTypeTrait<T>::AT)
+        << "required type is " << OpDataTypeTrait<T>::ATN
         << " not match the true type";
     return pair.first->second.get<T>();
   }

lite/model_parser/cpp/program_desc.h

@@ -38,6 +38,11 @@ class ProgramDesc : public ProgramDescAPI {
 
   std::vector<BlockDesc>& GetBlocks() { return blocks_; }
 
+  template <typename T>
+  T const* GetBlock(int32_t idx) const {
+    return GetBlock<T>(idx);
+  }
+
   template <typename T>
   T* AddBlock();
 

lite/model_parser/desc_apis.h

@@ -13,249 +13,9 @@
 // limitations under the License.
 
 #pragma once
-#include <map>
-#include <string>
-#include <vector>
-#include "lite/utils/all.h"
-#include "lite/utils/replace_stl/stream.h"
-
-namespace paddle {
-namespace lite {
-
-/*
- * Compatible interfaces for all the different kinds of XXXDesc. All the XXXDesc
- * classes should implement this.
- */
-
-class VarDescAPI {
- public:
-  enum class Type {
-    // Pod Types
-    BOOL = 0,
-    INT16,
-    INT32,
-    INT64,
-    FP16,
-    FP32,
-    FP64,
-    // Tensor<size_t> is used in C++.
-    SIZE_T,
-    UINT8,
-    INT8,
-
-    // Other types that may need additional descriptions
-    LOD_TENSOR,
-    SELECTED_ROWS,
-    FEED_MINIBATCH,
-    FETCH_LIST,
-    STEP_SCOPES,
-    LOD_RANK_TABLE,
-    LOD_TENSOR_ARRAY,
-    PLACE_LIST,
-    READER,
-    // Any runtime decided variable type is raw
-    // raw variables should manage their own allocations
-    // in operators like nccl_op
-    RAW,
-    TUPLE
-  };
-
-  using VarDataType = Type;
-
-  virtual ~VarDescAPI() = default;
-
-  // Get var's name
-  virtual std::string Name() const = 0;
-  // Set var's name
-  virtual void SetName(std::string name) = 0;
-  // Get var's type
-  virtual Type GetType() const = 0;
-  // Set var's type
-  virtual void SetType(Type type) = 0;
-  // Tell whether var is persistable or not
-  virtual bool Persistable() const = 0;
-  // Set var to be persistable or not
-  virtual void SetPersistable(bool persistable) = 0;
-  // Get var's shape
-  virtual std::vector<int64_t> GetShape() const = 0;
-  // Set var's shape
-  virtual void SetShape(const std::vector<int64_t>& dims) = 0;
-};
-
-/*
- * NOTE Some interfaces are weried, we remain them unchanged to keep compatible
- * with framework::OpDesc in Fluid framework.
- */
-class OpDescAPI {
- public:
-  // The AttrType is used to make the proto::AttrType portable.
-  enum class AttrType {
-    INT = 0,
-    FLOAT = 1,
-    STRING = 2,
-    INTS = 3,
-    FLOATS = 4,
-    STRINGS = 5,
-    BOOLEAN = 6,
-    BOOLEANS = 7,
-    BLOCK = 8,
-    LONG = 9,
-    BLOCKS = 10,
-    LONGS = 11,
-    UNK,
-  };
-
-  template <AttrType Type>
-  struct AttrTypeTrait;
-
-  template <typename T>
-  struct DataTypeTrait;
-
-  virtual ~OpDescAPI() = default;
-
-  /// Get operator's type.
-  virtual std::string Type() const = 0;
-  /// Set operator's type.
-  virtual void SetType(const std::string& type) = 0;
-  /// Get arguments given the parameter.
-  virtual std::vector<std::string> Input(const std::string& param) const = 0;
-  /// Get parameters.
-  virtual std::vector<std::string> InputArgumentNames() const = 0;
-  /// Get arguments given the parameter.
-  virtual std::vector<std::string> Output(const std::string& param) const = 0;
-  /// Get parameters.
-  virtual std::vector<std::string> OutputArgumentNames() const = 0;
-  /// Set a input given the parameter and arguments.
-  virtual void SetInput(const std::string& param,
-                        const std::vector<std::string>& args) = 0;
-  virtual void SetOutput(const std::string& param,
-                         const std::vector<std::string>& args) = 0;
-  /// Tell whether this desc has an attribute.
-  virtual bool HasAttr(const std::string& name) const = 0;
-
-  /// Get the type of an attribute.
-  virtual AttrType GetAttrType(const std::string& name) const = 0;
-
-  virtual std::vector<std::string> AttrNames() const = 0;
-
-  /// Set an attribute.
-  template <typename T>
-  void SetAttr(const std::string& name, const T& v);
-
-  /// Get an attribute.
-  template <typename T>
-  T GetAttr(const std::string& name) const;
-
-  std::string Repr() const {
-    STL::stringstream ss;
-    ss << Type();
-    ss << "(";
-    for (auto& arg : InputArgumentNames()) {
-      ss << arg << ":";
-      for (auto val : Input(arg)) {
-        ss << val << " ";
-      }
-    }
-    ss << ") -> (";
-    for (auto& arg : OutputArgumentNames()) {
-      ss << arg << ":";
-      for (auto val : Output(arg)) {
-        ss << val << " ";
-      }
-    }
-    ss << ")";
-    return ss.str();
-  }
-};
-
-#define TYPE_TRAIT_IMPL(T, type__)                          \
-  template <>                                               \
-  struct OpDescAPI::AttrTypeTrait<OpDescAPI::AttrType::T> { \
-    typedef type__ DT;                                      \
-  };                                                        \
-  template <>                                               \
-  struct OpDescAPI::DataTypeTrait<type__> {                 \
-    static constexpr AttrType AT = OpDescAPI::AttrType::T;  \
-    static constexpr const char* ATN = #T;                  \
-  };
-
-TYPE_TRAIT_IMPL(INT, int32_t);
-TYPE_TRAIT_IMPL(FLOAT, float);
-TYPE_TRAIT_IMPL(STRING, std::string);
-TYPE_TRAIT_IMPL(BOOLEAN, bool);
-TYPE_TRAIT_IMPL(LONG, int64_t);
-TYPE_TRAIT_IMPL(INTS, std::vector<int>);
-TYPE_TRAIT_IMPL(FLOATS, std::vector<float>);
-TYPE_TRAIT_IMPL(STRINGS, std::vector<std::string>);
-TYPE_TRAIT_IMPL(LONGS, std::vector<int64_t>);
-#undef TYPE_TRAIT_IMPL
-
-class BlockDescAPI {
- public:
-  virtual ~BlockDescAPI() = default;
-
-  virtual int32_t Idx() const = 0;
 
-  virtual void SetIdx(int32_t idx) = 0;
-
-  virtual int32_t ParentIdx() const = 0;
-
-  virtual void SetParentIdx(int32_t idx) = 0;
-
-  virtual size_t VarsSize() const = 0;
-
-  virtual void ClearVars() = 0;
-
-  // NOTE: This ugly method is used to compatible interfaces between cpp and
-  // pb/nb backends
-  // TODO(sangoly): refine this
-  template <typename T>
-  T* GetVar(int32_t idx);
-
-  template <typename T>
-  T* AddVar();
-
-  virtual size_t OpsSize() const = 0;
-
-  virtual void ClearOps() = 0;
-
-  // NOTE: This ugly method is used to compatible interfaces between cpp and
-  // pb/nb backends
-  // TODO(sangoly): refine this
-  template <typename T>
-  T* GetOp(int32_t idx);
-
-  template <typename T>
-  T* AddOp();
-
-  virtual int32_t ForwardBlockIdx() const = 0;
-
-  virtual void SetForwardBlockIdx(int32_t idx) = 0;
-};
-
-class ProgramDescAPI {
- public:
-  virtual ~ProgramDescAPI() = default;
-
-  virtual size_t BlocksSize() const = 0;
-
-  virtual void ClearBlocks() = 0;
-
-  // NOTE: This ugly method is used to compatible interfaces between cpp and
-  // pb/nb backends
-  // TODO(sangoly): refine this
-  template <typename T>
-  T* GetBlock(int32_t idx);
-
-  template <typename T>
-  T* AddBlock();
-
-  virtual bool HasVersion() const = 0;
-
-  virtual int64_t Version() const = 0;
-
-  virtual void SetVersion(int64_t version) = 0;
-};
-
-}  // namespace lite
-}  // namespace paddle
+#include "lite/model_parser/base/block_desc.h"
+#include "lite/model_parser/base/op_desc.h"
+#include "lite/model_parser/base/program_desc.h"
+#include "lite/model_parser/base/var_desc.h"
+#include "lite/utils/all.h"

lite/model_parser/naive_buffer/block_desc.h

@@ -55,6 +55,11 @@ class BlockDesc : public BlockDescAPI {
   template <typename T>
   T* GetVar(int32_t idx);
 
+  template <typename T>
+  T const* GetVar(int32_t idx) const {
+    return GetVar<T>(idx);
+  }
+
   template <typename T>
   T* AddVar();
 
@@ -65,6 +70,11 @@ class BlockDesc : public BlockDescAPI {
   template <typename T>
   T* GetOp(int32_t idx);
 
+  template <typename T>
+  T const* GetOp(int32_t idx) const {
+    return GetOp<T>(idx);
+  }
+
   template <typename T>
   T* AddOp();
 

lite/model_parser/naive_buffer/program_desc.h

@@ -45,6 +45,11 @@ class ProgramDesc : public ProgramDescAPI {
   template <typename T>
   T *GetBlock(int32_t idx);
 
+  template <typename T>
+  T const *GetBlock(int32_t idx) const {
+    return GetBlock<T>(idx);
+  }
+
   template <typename T>
   T *AddBlock();
 

lite/model_parser/pb/block_desc.h

@@ -50,6 +50,11 @@ class BlockDesc : public BlockDescAPI {
   template <typename T>
   T* GetVar(int32_t idx);
 
+  template <typename T>
+  T const* GetVar(int32_t idx) const {
+    return GetVar<T>(idx);
+  }
+
   template <typename T>
   T* AddVar();
 
@@ -60,6 +65,11 @@ class BlockDesc : public BlockDescAPI {
   template <typename T>
   T* GetOp(int32_t idx);
 
+  template <typename T>
+  T const* GetOp(int32_t idx) const {
+    return GetOp<T>(idx);
+  }
+
   template <typename T>
   T* AddOp();
 

lite/model_parser/pb/program_desc.h

@@ -42,6 +42,11 @@ class ProgramDesc : public ProgramDescAPI {
   template <typename T>
   T *GetBlock(int32_t idx);
 
+  template <typename T>
+  T const *GetBlock(int32_t idx) const {
+    return GetBlock<T>(idx);
+  }
+
   template <typename T>
   T *AddBlock();