remove third-party folder

CMakeLists.txt

@@ -27,29 +27,12 @@ include_directories(src/)
 #        INSTALL_COMMAND "make" "PREFIX=${CMAKE_BINARY_DIR}/" "install"
 #        )
 #set_target_properties(openblas_proj PROPERTIES EXCLUDE_FROM_ALL 1)
-# link protobuf
-include_directories(third-party/protobuf/include)
-include_directories(third-party/protobuf-c-decoder/include)
-if (ANDROID)
-    link_directories(third-party/protobuf/armeabi-v7a)
-else()
-    # link openblas
-    link_directories(third-party/protobuf/lib)
-    link_directories(third-party/protobuf-c-decoder/lib)
-endif ()
 
 #add_dependencies(paddle-mobile openblas_proj)
 
 # gen static
 ADD_LIBRARY(paddle-mobile SHARED ${PADDLE_MOBILE_CC} ${PADDLE_MOBILE_H})
 
-if (ANDROID)
-    # openblas.a need log lib
-    target_link_libraries(paddle-mobile protobuf-lite)
-else()
-    target_link_libraries(paddle-mobile protobuf-lite)
-    target_link_libraries(paddle-mobile protobuf-c-decoder)
-endif ()
 #add_dependencies(paddle-mobile openblas_proj)
 
 add_subdirectory(test)

src/common/type_define.h

@@ -17,6 +17,7 @@ limitations under the License. */
 #include <map>
 #include <string>
 #include <vector>
+#include <unordered_set>
 #include "framework/attribute.h"
 #include "framework/scope.h"
 

src/framework/attribute.h

@@ -14,10 +14,10 @@ limitations under the License. */
 
 #pragma once
 
+#include <unordered_map>
 #include "common/log.h"
 #include "common/enforce.h"
 #include "common/variant.h"
-#include "framework/framework.pb.h"
 #include "framework/framework.pb-c.h"
 
 namespace paddle_mobile {
@@ -27,69 +27,6 @@ class BlockDesc;
 
 class Attribute {
  public:
-  static Attribute GetAttrValue(const proto::OpDesc::Attr &attr_desc) {
-    //    std::cout << "begin get attr value" << std::endl;
-    Attribute attr;
-    switch (attr_desc.type()) {
-      case proto::AttrType::BOOLEAN: {
-        attr.Set<bool>(attr_desc.b());
-        break;
-      }
-      case proto::AttrType::INT: {
-        attr.Set<int>(attr_desc.i());
-        break;
-      }
-      case proto::AttrType::FLOAT: {
-        attr.Set<float>(attr_desc.f());
-        break;
-      }
-      case proto::AttrType::STRING: {
-        attr.Set<std::string>(attr_desc.s());
-        break;
-      }
-      case proto::AttrType::BOOLEANS: {
-        std::vector<bool> val(attr_desc.bools_size());
-        for (int i = 0; i < attr_desc.bools_size(); ++i) {
-          val[i] = attr_desc.bools(i);
-        }
-        attr.Set<std::vector<bool>>(val);
-        break;
-      }
-      case proto::AttrType::INTS: {
-        std::vector<int> val(attr_desc.ints_size());
-        for (int i = 0; i < attr_desc.ints_size(); ++i) {
-          val[i] = attr_desc.ints(i);
-        }
-        attr.Set<std::vector<int>>(val);
-        break;
-      }
-      case proto::AttrType::FLOATS: {
-        std::vector<float> val(attr_desc.floats_size());
-        for (int i = 0; i < attr_desc.floats_size(); ++i) {
-          val[i] = attr_desc.floats(i);
-        }
-        attr.Set<std::vector<float>>(val);
-        break;
-      }
-      case proto::AttrType::STRINGS: {
-        std::vector<std::string> val(attr_desc.strings_size());
-        for (int i = 0; i < attr_desc.strings_size(); ++i) {
-          val[i] = attr_desc.strings(i);
-        }
-        attr.Set<std::vector<std::string>>(val);
-        break;
-      }
-      case proto::AttrType::LONG: {
-        attr.Set<int64_t>(attr_desc.l());
-        break;
-      }
-      default:
-        //        std::cout << " not support " << std::endl;
-        break;
-    }
-    //    std::cout << "end get attr value" << std::endl;
-    return attr;
-  }
 
   /*
    *  PADDLE_MOBILE__FRAMEWORK__PROTO__ATTR_TYPE__INT = 0,

src/framework/data_type.h

@@ -14,8 +14,6 @@ limitations under the License. */
 
 #pragma once
 
-#include "framework/framework.pb.h"
-
 namespace paddle_mobile {
 namespace framework {
 

src/framework/framework.pb-c.h

@@ -4,7 +4,7 @@
 #ifndef PROTOBUF_C_framework_2eproto__INCLUDED
 #define PROTOBUF_C_framework_2eproto__INCLUDED
 
-#include "protobuf-c.h"
+#include "common/protobuf-c.h"
 
 PROTOBUF_C__BEGIN_DECLS
 

src/framework/lod_tensor.cpp

@@ -244,58 +244,5 @@ void AppendLoD(LoD *lod, const LoD &lod_length) {
   }
 }
 
-void SerializeToStream(std::ostream &os, const LoDTensor &tensor) {
-  {  // the 1st field, uint32_t version for LoDTensor
-    constexpr uint32_t version = 0;
-    os.write(reinterpret_cast<const char *>(&version), sizeof(version));
-  }
-  {
-    // the 2st field, LoD information
-    // uint64_t lod_level
-    // uint64_t lod_level_1 size in byte.
-    // int*     lod_level_1 data
-    // ...
-    auto lod = tensor.lod();
-    uint64_t size = lod.size();
-    os.write(reinterpret_cast<const char *>(&size), sizeof(size));
-
-    for (auto &each : lod) {
-      size = each.size() * sizeof(framework::LoD::value_type::value_type);
-      os.write(reinterpret_cast<const char *>(&size), sizeof(size));
-      os.write(reinterpret_cast<const char *>(each.data()),
-               static_cast<std::streamsize>(size));
-    }
-  }
-  // the 3st field, Tensor
-  TensorToStream(os, static_cast<Tensor>(tensor));
-}
-
-void DeserializeFromStream(std::istream &is, LoDTensor *tensor) {
-  {
-    // the 1st field, unit32_t version for LoDTensor
-    uint32_t version;
-    is.read(reinterpret_cast<char *>(&version), sizeof(version));
-    //    PADDLE_ENFORCE_EQ(version, 0U, "Only version 0 is
-    //    supported");
-  }
-  {
-    // the 2st field, LoD information
-    uint64_t lod_level;
-    is.read(reinterpret_cast<char *>(&lod_level), sizeof(lod_level));
-    auto &lod = *tensor->mutable_lod();
-    lod.resize(lod_level);
-    for (uint64_t i = 0; i < lod_level; ++i) {
-      uint64_t size;
-      is.read(reinterpret_cast<char *>(&size), sizeof(size));
-      std::vector<size_t> tmp(size / sizeof(size_t));
-      is.read(reinterpret_cast<char *>(tmp.data()),
-              static_cast<std::streamsize>(size));
-      lod[i] = tmp;
-    }
-  }
-  // the 3st filed, Tensor
-  TensorFromStream(is, static_cast<Tensor *>(tensor));
-}
-
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/op_info.h

@@ -17,7 +17,6 @@ limitations under the License. */
 #include <string>
 #include "common/log.h"
 #include "common/type_define.h"
-#include "framework/framework.pb.h"
 
 namespace paddle_mobile {
 namespace framework {

src/framework/op_kernel_type.h

@@ -15,7 +15,7 @@ limitations under the License. */
 #pragma once
 
 #include "framework/data_layout.h"
-#include "framework/framework.pb.h"
+#include "framework/program/tensor_desc.h"
 
 namespace paddle_mobile {
 namespace framework {
@@ -33,10 +33,10 @@ struct OpKernelType {
   // place, data_type, library_type kinds less than 2^8
   constexpr static int LEFT_SHIFT = 8;
 
-  proto::VarType::Type data_type_;
+  VarType_Type data_type_;
   DataLayout data_layout_;
 
-  OpKernelType(proto::VarType::Type data_type,
+  OpKernelType(VarType_Type data_type,
                DataLayout data_layout = DataLayout::kAnyLayout)
       : data_type_(data_type), data_layout_(data_layout) {}
 

src/framework/program/block_desc.h

@@ -14,7 +14,6 @@ limitations under the License. */
 
 #pragma once
 
-#include "framework/framework.pb.h"
 #include "framework/framework.pb-c.h"
 #include "framework/program/op_desc.h"
 #include "framework/program/var_desc.h"

src/framework/program/op_desc.h

@@ -19,7 +19,6 @@ limitations under the License. */
 
 #include "common/log.h"
 #include "common/type_define.h"
-#include "framework/framework.pb.h"
 #include "framework/framework.pb-c.h"
 #include "framework/paddle_mobile_object.h"
 

src/framework/program/var_desc.h

@@ -14,7 +14,6 @@ limitations under the License. */
 
 #pragma once
 
-#include "framework/framework.pb.h"
 #include "framework/framework.pb-c.h"
 #include "framework/program/tensor_desc.h"
 #include "framework/paddle_mobile_object.h"

src/framework/tensor_util.cpp

@@ -132,37 +132,6 @@ bool TensorContainsInf(const framework::Tensor &tensor) {
   return Any(tensor, predicate);
 }
 
-void TensorToStream(std::ostream &os, const Tensor &tensor) {
-  {  // the 1st field, uint32_t version
-    constexpr uint32_t version = 0;
-    os.write(reinterpret_cast<const char *>(&version), sizeof(version));
-  }
-  {  // the 2nd field, tensor description
-    // int32_t  size
-    // void*    protobuf message
-    proto::VarType::TensorDesc desc;
-    desc.set_data_type(framework::ToDataType(tensor.type()));
-    auto dims = framework::vectorize(tensor.dims());
-    auto *pb_dims = desc.mutable_dims();
-    pb_dims->Resize(static_cast<int>(dims.size()), 0);
-    std::copy(dims.begin(), dims.end(), pb_dims->begin());
-    int32_t size = desc.ByteSize();
-    os.write(reinterpret_cast<const char *>(&size), sizeof(size));
-    auto out = desc.SerializeAsString();
-    os.write(out.data(), size);
-  }
-  {  // the 3rd field, tensor data
-    uint64_t size = tensor.memory_size();
-    auto *data_ptr = tensor.data<void>();
-    //    PADDLE_ENFORCE(size <
-    //    std::numeric_limits<std::streamsize>::max(),
-    //                   "Index overflow when writing tensor");
-
-    os.write(static_cast<const char *>(data_ptr),
-             static_cast<std::streamsize>(size));
-  }
-}
-
 struct DeserializedDataFunctor {
   DeserializedDataFunctor(void **buf, Tensor *tensor)
       : buf_(buf), tensor_(tensor) {}
@@ -176,32 +145,5 @@ struct DeserializedDataFunctor {
   Tensor *tensor_;
 };
 
-void TensorFromStream(std::istream &is, framework::Tensor *tensor) {
-  uint32_t version;
-  is.read(reinterpret_cast<char *>(&version), sizeof(version));
-  //  PADDLE_ENFORCE_EQ(version, 0U, "Only version 0 is supported");
-  proto::VarType::TensorDesc desc;
-  {  // int32_t size
-    // proto buffer
-    int32_t size;
-    is.read(reinterpret_cast<char *>(&size), sizeof(size));
-    std::unique_ptr<char[]> buf(new char[size]);
-    is.read(reinterpret_cast<char *>(buf.get()), size);
-    //    PADDLE_ENFORCE(desc.ParseFromArray(buf.get(), size),
-    //                   "Cannot parse tensor desc");
-  }
-  {  // read tensor
-    std::vector<int64_t> dims;
-    dims.reserve(static_cast<size_t>(desc.dims().size()));
-    std::copy(desc.dims().begin(), desc.dims().end(), std::back_inserter(dims));
-    tensor->Resize(framework::make_ddim(dims));
-    void *buf;
-
-    framework::VisitDataType(desc.data_type(),
-                             DeserializedDataFunctor(&buf, tensor));
-    is.read(static_cast<char *>(buf), tensor->memory_size());
-  }
-}
-
 }  // namespace framework
 }  // namespace paddle_mobile

src/framework/tensor_util.h

@@ -14,7 +14,6 @@ limitations under the License. */
 
 #pragma once
 #include <vector>
-#include "framework.pb.h"
 #include "memory/t_malloc.h"
 #include "platform/data_type.h"
 #include "tensor.h"

src/io.cpp

@@ -22,7 +22,6 @@ limitations under the License. */
 #include "framework/tensor.h"
 #include "framework/operator.h"
 #include "framework/lod_tensor.h"
-#include "framework/framework.pb.h"
 #include "framework/framework.pb-c.h"
 #include "framework/program/var_desc.h"
 #include "framework/program/program_desc.h"
@@ -110,6 +109,14 @@ void Loader<Dtype, P>::LoadVar(framework::Variable *variable, const framework::V
 
   const framework::TensorDesc &desc = var_desc.Tensor_desc();
 
+
+  PaddleMobile__Framework__Proto__VarType__TensorDesc *tensor_desc = NULL;
+//  void *v;
+//  PaddleMobile__Framework__Proto__VarType__TensorDesc_Closure()(tensor_desc, buf.get());
+
+//  DLOG << "PaddleMobile__Framework__Proto__VarType__TensorDesc_Closure- " << tensor_desc;
+
+
 //  framework::TensorDesc &tensor_desc = variable->
 //  PaddleMobile__Framework__Proto__ProgramDesc *c_program;
 //  uint8_t *proto_buf = NULL;
@@ -240,7 +247,7 @@ Executor<Dtype, P>::Executor(const framework::Program<Dtype> p) : program_(p) {
 }
 
 template <typename Dtype, Precision P>
-void Executor<Dtype, P>::LoadMemory(framework::LoDTensor *tensor,
+void Executor<Dtype, P>::LoadMemory(const framework::VarDesc var_desc, framework::LoDTensor *tensor,
                                     const std::string &file_path) {
   std::ifstream is(file_path);
   PADDLE_MOBILE_ENFORCE(is.is_open(), "open file: %s failed",
@@ -281,39 +288,36 @@ void Executor<Dtype, P>::LoadMemory(framework::LoDTensor *tensor,
   std::unique_ptr<char[]> buf(new char[size]);
   is.read(reinterpret_cast<char *>(buf.get()), size);
 
-  framework::proto::VarType::TensorDesc desc;
-  desc.ParseFromArray(buf.get(), size);
+  const framework::TensorDesc &desc = var_desc.Tensor_desc();
+
 
   int memory_size = 1;
-  for (auto l : desc.dims()) {
+  for (auto l : desc.Dims()) {
     memory_size *= l;
   }
 
-  std::vector<int64_t> dims;
-  dims.reserve(static_cast<size_t>(desc.dims().size()));
-  std::copy(desc.dims().begin(), desc.dims().end(), std::back_inserter(dims));
-  tensor->Resize(framework::make_ddim(dims));
+  tensor->Resize(framework::make_ddim(desc.Dims()));
 
   void *memory = tensor;
   int type_size = 0;
-  switch (desc.data_type()) {
-    case framework::proto::VarType::FP16:
+  switch (desc.DataType()) {
+    case framework::VARTYPE_TYPE_FP16:
       type_size = 2;
       break;
-    case framework::proto::VarType::FP32:
+    case framework::VARTYPE_TYPE_FP32:
       type_size = 4;
       memory = tensor->mutable_data<float>();
       break;
-    case framework::proto::VarType::FP64:
+    case framework::VARTYPE_TYPE_FP64:
       type_size = 8;
       break;
-    case framework::proto::VarType::INT32:
+    case framework::VARTYPE_TYPE_INT32:
       type_size = 4;
       break;
-    case framework::proto::VarType::INT64:
+    case framework::VARTYPE_TYPE_INT64:
       type_size = 8;
       break;
-    case framework::proto::VarType::BOOL:
+    case framework::VARTYPE_TYPE_BOOL:
       type_size = 1;
       break;
     default:
@@ -331,7 +335,7 @@ void Executor<Dtype, P>::InitMemory() {
       auto var = program_.scope->Var(var_desc->Name());
       if (var_desc->Persistable()) {
         auto tensor = var->template GetMutable<framework::LoDTensor>();
-        LoadMemory(tensor, program_.model_path + "/" + var_desc->Name());
+        LoadMemory(*var_desc, tensor, program_.model_path + "/" + var_desc->Name());
       } else {
         if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
           auto tensor = var->template GetMutable<framework::Tensor>();

src/io.h

@@ -52,7 +52,7 @@ class Executor {
 
  protected:
   void InitMemory();
-  void LoadMemory(framework::LoDTensor *tensor, const std::string &file_path);
+  void LoadMemory(const framework::VarDesc var_desc, framework::LoDTensor *tensor, const std::string &file_path);
   framework::Program<Dtype> program_;
   std::shared_ptr<framework::ProgramDesc> to_predict_program_;
   void predict(const framework::Tensor &t, int block_id);

src/platform/data_type.h

@@ -16,12 +16,13 @@ limitations under the License. */
 
 #include <string>
 #include <typeindex>
-#include "framework/framework.pb.h"
+
+#include "framework/program/tensor_desc.h"
 
 namespace paddle_mobile {
 namespace framework {
 
-inline proto::VarType::Type ToDataType(std::type_index type) {
+inline VarType_Type ToDataType(std::type_index type) {
   /*if (typeid(platform::float16).hash_code() == type.hash_code()) {
     return proto::VarType::FP16;
   } else */
@@ -31,34 +32,34 @@ inline proto::VarType::Type ToDataType(std::type_index type) {
     // One fix to this is to replace float with const float because
     // typeid(T) == typeid(const T)
     // http://en.cppreference.com/w/cpp/language/typeid
-    return proto::VarType::FP32;
+    return VARTYPE_TYPE_FP32;
   } else if (typeid(const double).hash_code() == type.hash_code()) {
-    return proto::VarType::FP64;
+    return VARTYPE_TYPE_FP64;
   } else if (typeid(const int).hash_code() == type.hash_code()) {
-    return proto::VarType::INT32;
+    return VARTYPE_TYPE_INT32;
   } else if (typeid(const int64_t).hash_code() == type.hash_code()) {
-    return proto::VarType::INT64;
+    return VARTYPE_TYPE_INT64;
   } else if (typeid(const bool).hash_code() == type.hash_code()) {
-    return proto::VarType::BOOL;
+    return VARTYPE_TYPE_BOOL;
   } else {
     //    PADDLE_THROW("Not supported");
     //    std::cout << "Not supported";
   }
 }
 
-inline std::type_index ToTypeIndex(proto::VarType::Type type) {
+inline std::type_index ToTypeIndex(VarType_Type type) {
   switch (type) {
     //    case proto::VarType::FP16:
     //      return typeid(platform::float16);
-    case proto::VarType::FP32:
+    case VARTYPE_TYPE_FP32:
       return typeid(float);
-    case proto::VarType::FP64:
+    case VARTYPE_TYPE_FP64:
       return typeid(double);
-    case proto::VarType::INT32:
+    case VARTYPE_TYPE_INT32:
       return typeid(int);
-    case proto::VarType::INT64:
+    case VARTYPE_TYPE_INT64:
       return typeid(int64_t);
-    case proto::VarType::BOOL:
+    case VARTYPE_TYPE_BOOL:
       return typeid(bool);
     default:
       //      PADDLE_THROW("Not support type %d", type);
@@ -67,24 +68,24 @@ inline std::type_index ToTypeIndex(proto::VarType::Type type) {
 }
 
 template <typename Visitor>
-inline void VisitDataType(proto::VarType::Type type, Visitor visitor) {
+inline void VisitDataType(VarType_Type type, Visitor visitor) {
   switch (type) {
     //    case proto::VarType::FP16:
     //      visitor.template operator()<platform::float16>();
     //      break;
-    case proto::VarType::FP32:
+    case VARTYPE_TYPE_FP32:
       visitor.template operator()<float>();
       break;
-    case proto::VarType::FP64:
+    case VARTYPE_TYPE_FP64:
       visitor.template operator()<double>();
       break;
-    case proto::VarType::INT32:
+    case VARTYPE_TYPE_INT32:
       visitor.template operator()<int>();
       break;
-    case proto::VarType::INT64:
+    case VARTYPE_TYPE_INT64:
       visitor.template operator()<int64_t>();
       break;
-    case proto::VarType::BOOL:
+    case VARTYPE_TYPE_BOOL:
       visitor.template operator()<bool>();
       break;
     default:
@@ -93,21 +94,21 @@ inline void VisitDataType(proto::VarType::Type type, Visitor visitor) {
   }
 }
 
-inline std::string DataTypeToString(const proto::VarType::Type type) {
+inline std::string DataTypeToString(const VarType_Type type) {
   switch (type) {
-    case proto::VarType::FP16:
+    case VARTYPE_TYPE_FP16:
       return "float16";
-    case proto::VarType::FP32:
+    case VARTYPE_TYPE_FP32:
       return "float32";
-    case proto::VarType::FP64:
+    case VARTYPE_TYPE_FP64:
       return "float64";
-    case proto::VarType::INT16:
+    case VARTYPE_TYPE_INT16:
       return "int16";
-    case proto::VarType::INT32:
+    case VARTYPE_TYPE_INT32:
       return "int32";
-    case proto::VarType::INT64:
+    case VARTYPE_TYPE_INT64:
       return "int64";
-    case proto::VarType::BOOL:
+    case VARTYPE_TYPE_BOOL:
       return "bool";
     default:
       //      PADDLE_THROW("Not support type %d", type);
@@ -116,7 +117,7 @@ inline std::string DataTypeToString(const proto::VarType::Type type) {
 }
 
 inline std::ostream &operator<<(std::ostream &out,
-                                const proto::VarType::Type &type) {
+                                const VarType_Type &type) {
   out << DataTypeToString(type);
   return out;
 }

test/test_include.h

@@ -21,7 +21,6 @@ limitations under the License. */
 #include "./test_helper.h"
 #include "common/enforce.h"
 #include "common/log.h"
-#include "framework/framework.pb.h"
 #include "framework/lod_tensor.h"
 #include "framework/operator.h"
 #include "framework/program/block_desc.h"