Move DataType enum inside VarType

paddle/fluid/framework/backward.cc

@@ -341,7 +341,7 @@ static void CreateGradVarInBlock(
       auto* param = block_desc->FindVarRecursive(pname);
       auto* grad = block_desc->FindVar(arg);
       if (param == nullptr) {
-        grad->SetDataType(proto::DataType::FP32);
+        grad->SetDataType(proto::VarType::FP32);
       } else {
         grad->SetDataType(param->GetDataType());
       }

paddle/fluid/framework/data_device_transform_test.cu

@@ -51,10 +51,10 @@ class TestOpWithKernel : public OperatorWithKernel {
       const ExecutionContext& ctx) const override {
     if (Attr<bool>("use_gpu")) {
       VLOG(3) << "force use gpu kernel";
-      return OpKernelType(proto::DataType::FP32, platform::CUDAPlace(0));
+      return OpKernelType(proto::VarType::FP32, platform::CUDAPlace(0));
     } else {
       VLOG(3) << "use default kernel";
-      return OpKernelType(proto::DataType::FP32,
+      return OpKernelType(proto::VarType::FP32,
                           ctx.Input<Tensor>("input")->place());
     }
   }

paddle/fluid/framework/data_layout_transform_test.cc

@@ -27,9 +27,9 @@ TEST(DataTransform, DataLayoutFunction) {
   in.mutable_data<double>(make_ddim({2, 3, 1, 2}), place);
   in.set_layout(DataLayout::kNHWC);
 
-  auto kernel_nhwc = OpKernelType(proto::DataType::FP32, place,
+  auto kernel_nhwc = OpKernelType(proto::VarType::FP32, place,
                                   DataLayout::kNHWC, LibraryType::kPlain);
-  auto kernel_ncwh = OpKernelType(proto::DataType::FP32, place,
+  auto kernel_ncwh = OpKernelType(proto::VarType::FP32, place,
                                   DataLayout::kNCHW, LibraryType::kPlain);
 
   TransDataLayout(kernel_nhwc, kernel_ncwh, in, &out);

paddle/fluid/framework/data_type.h

@@ -20,89 +20,89 @@ limitations under the License. */
 namespace paddle {
 namespace framework {
 
-inline proto::DataType ToDataType(std::type_index type) {
+inline proto::VarType::Type ToDataType(std::type_index type) {
   using namespace paddle::framework::proto;
   if (typeid(float).hash_code() == type.hash_code()) {
-    return DataType::FP32;
+    return proto::VarType::FP32;
   } else if (typeid(double).hash_code() == type.hash_code()) {
-    return DataType::FP64;
+    return proto::VarType::FP64;
   } else if (typeid(int).hash_code() == type.hash_code()) {
-    return DataType::INT32;
+    return proto::VarType::INT32;
   } else if (typeid(int64_t).hash_code() == type.hash_code()) {
-    return DataType::INT64;
+    return proto::VarType::INT64;
   } else if (typeid(bool).hash_code() == type.hash_code()) {
-    return DataType::BOOL;
+    return proto::VarType::BOOL;
   } else {
     PADDLE_THROW("Not supported");
   }
 }
 
-inline std::type_index ToTypeIndex(proto::DataType type) {
+inline std::type_index ToTypeIndex(proto::VarType::Type type) {
   using namespace paddle::framework::proto;
   switch (type) {
-    case DataType::FP32:
+    case proto::VarType::FP32:
       return typeid(float);
-    case DataType::FP64:
+    case proto::VarType::FP64:
       return typeid(double);
-    case DataType::INT32:
+    case proto::VarType::INT32:
       return typeid(int);
-    case DataType::INT64:
+    case proto::VarType::INT64:
       return typeid(int64_t);
-    case DataType::BOOL:
+    case proto::VarType::BOOL:
       return typeid(bool);
     default:
       PADDLE_THROW("Not support type %d", type);
   }
 }
 
 template <typename Visitor>
-inline void VisitDataType(proto::DataType type, Visitor visitor) {
+inline void VisitDataType(proto::VarType::Type type, Visitor visitor) {
   using namespace paddle::framework::proto;
   switch (type) {
-    case DataType::FP32:
+    case proto::VarType::FP32:
       visitor.template operator()<float>();
       break;
-    case DataType::FP64:
+    case proto::VarType::FP64:
       visitor.template operator()<double>();
       break;
-    case DataType::INT32:
+    case proto::VarType::INT32:
       visitor.template operator()<int>();
       break;
-    case DataType::INT64:
+    case proto::VarType::INT64:
       visitor.template operator()<int64_t>();
       break;
-    case DataType::BOOL:
+    case proto::VarType::BOOL:
       visitor.template operator()<bool>();
       break;
     default:
       PADDLE_THROW("Not supported");
   }
 }
 
-inline std::string DataTypeToString(const proto::DataType type) {
+inline std::string DataTypeToString(const proto::VarType::Type type) {
   using namespace paddle::framework::proto;
   switch (type) {
-    case DataType::FP16:
+    case proto::VarType::FP16:
       return "float16";
-    case DataType::FP32:
+    case proto::VarType::FP32:
       return "float32";
-    case DataType::FP64:
+    case proto::VarType::FP64:
       return "float64";
-    case DataType::INT16:
+    case proto::VarType::INT16:
       return "int16";
-    case DataType::INT32:
+    case proto::VarType::INT32:
       return "int32";
-    case DataType::INT64:
+    case proto::VarType::INT64:
       return "int64";
-    case DataType::BOOL:
+    case proto::VarType::BOOL:
       return "bool";
     default:
       PADDLE_THROW("Not support type %d", type);
   }
 }
 
 inline std::ostream& operator<<(std::ostream& out,
-                                const proto::DataType& type) {
+                                const proto::VarType::Type& type) {
   out << DataTypeToString(type);
   return out;
 }

paddle/fluid/framework/data_type_transform.cc

@@ -65,19 +65,19 @@ void TransDataType(const OpKernelType& kernel_type_for_var,
   auto ctx = pool.Get(in.place());
 
   switch (src_type) {
-    case proto::DataType::FP32:
+    case proto::VarType::FP32:
       framework::VisitDataType(dst_type, CastDataType<float>(in, out, ctx));
       break;
-    case proto::DataType::FP64:
+    case proto::VarType::FP64:
       framework::VisitDataType(dst_type, CastDataType<double>(in, out, ctx));
       break;
-    case proto::DataType::INT32:
+    case proto::VarType::INT32:
       framework::VisitDataType(dst_type, CastDataType<int>(in, out, ctx));
       break;
-    case proto::DataType::INT64:
+    case proto::VarType::INT64:
       framework::VisitDataType(dst_type, CastDataType<int64_t>(in, out, ctx));
       break;
-    case proto::DataType::BOOL:
+    case proto::VarType::BOOL:
       framework::VisitDataType(dst_type, CastDataType<bool>(in, out, ctx));
       break;
     default:

paddle/fluid/framework/data_type_transform_test.cc

@@ -32,11 +32,11 @@ TEST(DataTypeTransform, CPUTransform) {
     ptr[i] = i / 3;
   }
 
-  auto kernel_fp32 = OpKernelType(proto::DataType::FP32, place,
+  auto kernel_fp32 = OpKernelType(proto::VarType::FP32, place,
                                   DataLayout::kAnyLayout, LibraryType::kPlain);
-  auto kernel_fp64 = OpKernelType(proto::DataType::FP64, place,
+  auto kernel_fp64 = OpKernelType(proto::VarType::FP64, place,
                                   DataLayout::kAnyLayout, LibraryType::kPlain);
-  auto kernel_int32 = OpKernelType(proto::DataType::INT32, place,
+  auto kernel_int32 = OpKernelType(proto::VarType::INT32, place,
                                    DataLayout::kAnyLayout, LibraryType::kPlain);
 
   TransDataType(kernel_fp32, kernel_fp64, in, &out);

paddle/fluid/framework/framework.proto

@@ -91,33 +91,34 @@ message OpProto {
   required string comment = 5;
 }
 
-enum DataType {
-  BOOL = 0;
-  INT16 = 1;
-  INT32 = 2;
-  INT64 = 3;
-  FP16 = 4;
-  FP32 = 5;
-  FP64 = 6;
-}
-
 message VarType {
   enum Type {
-    LOD_TENSOR = 1;
-    SELECTED_ROWS = 2;
-    FEED_MINIBATCH = 3;
-    FETCH_LIST = 4;
-    STEP_SCOPES = 5;
-    LOD_RANK_TABLE = 6;
-    LOD_TENSOR_ARRAY = 7;
-    PLACE_LIST = 8;
-    READER = 9;
+    // Pod Types
+    BOOL = 0;
+    INT16 = 1;
+    INT32 = 2;
+    INT64 = 3;
+    FP16 = 4;
+    FP32 = 5;
+    FP64 = 6;
+
+    // Other types that may need additional descriptions
+    LOD_TENSOR = 7;
+    SELECTED_ROWS = 8;
+    FEED_MINIBATCH = 9;
+    FETCH_LIST = 10;
+    STEP_SCOPES = 11;
+    LOD_RANK_TABLE = 12;
+    LOD_TENSOR_ARRAY = 13;
+    PLACE_LIST = 14;
+    READER = 15;
   }
 
   required Type type = 1;
 
   message TensorDesc {
-    required DataType data_type = 1;
+    // Should only be PODType. Is enforced in C++
+    required Type data_type = 1;
     repeated int64 dims = 2; // [UNK, 640, 480] is saved as [-1, 640, 480]
   }
   optional TensorDesc selected_rows = 2;

paddle/fluid/framework/op_kernel_type.h

@@ -40,20 +40,20 @@ struct OpKernelType {
   // place, data_type, library_type kinds less than 2^8
   constexpr static int LEFT_SHIFT = 8;
 
-  proto::DataType data_type_;
+  proto::VarType::Type data_type_;
   DataLayout data_layout_;
   platform::Place place_;
   LibraryType library_type_;
 
-  OpKernelType(proto::DataType data_type, platform::Place place,
+  OpKernelType(proto::VarType::Type data_type, platform::Place place,
                DataLayout data_layout = DataLayout::kAnyLayout,
                LibraryType library_type = LibraryType::kPlain)
       : data_type_(data_type),
         data_layout_(data_layout),
         place_(place),
         library_type_(library_type) {}
 
-  OpKernelType(proto::DataType data_type,
+  OpKernelType(proto::VarType::Type data_type,
                const platform::DeviceContext& dev_ctx,
                DataLayout data_layout = DataLayout::kAnyLayout,
                LibraryType library_type = LibraryType::kPlain)

paddle/fluid/framework/op_kernel_type_test.cc

@@ -18,7 +18,7 @@ limitations under the License. */
 
 TEST(OpKernelType, ToString) {
   using OpKernelType = paddle::framework::OpKernelType;
-  using DataType = paddle::framework::proto::DataType;
+  using DataType = paddle::framework::proto::VarType;
   using CPUPlace = paddle::platform::CPUPlace;
   using DataLayout = paddle::framework::DataLayout;
   using LibraryType = paddle::framework::LibraryType;
@@ -33,7 +33,7 @@ TEST(OpKernelType, ToString) {
 
 TEST(OpKernelType, Hash) {
   using OpKernelType = paddle::framework::OpKernelType;
-  using DataType = paddle::framework::proto::DataType;
+  using DataType = paddle::framework::proto::VarType;
   using CPUPlace = paddle::platform::CPUPlace;
   using CUDAPlace = paddle::platform::CUDAPlace;
   using DataLayout = paddle::framework::DataLayout;

paddle/fluid/framework/op_registry_test.cc

@@ -226,7 +226,7 @@ class OpWithKernelTest : public OperatorWithKernel {
 
   framework::OpKernelType GetExpectedKernelType(
       const framework::ExecutionContext& ctx) const override {
-    return framework::OpKernelType(proto::DataType::FP32, ctx.device_context());
+    return framework::OpKernelType(proto::VarType::FP32, ctx.device_context());
   }
 };
 
@@ -290,9 +290,9 @@ class OpWithMultiKernelTest : public OperatorWithKernel {
 
   framework::OpKernelType GetExpectedKernelType(
       const framework::ExecutionContext& ctx) const override {
-    return framework::OpKernelType(
-        proto::DataType::FP32, platform::CUDAPlace(0), DataLayout::kAnyLayout,
-        framework::LibraryType::kCUDNN);
+    return framework::OpKernelType(proto::VarType::FP32, platform::CUDAPlace(0),
+                                   DataLayout::kAnyLayout,
+                                   framework::LibraryType::kCUDNN);
   }
 };
 

paddle/fluid/framework/operator.cc

@@ -569,7 +569,7 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
   }
 }
 
-proto::DataType OperatorWithKernel::IndicateDataType(
+proto::VarType::Type OperatorWithKernel::IndicateDataType(
     const ExecutionContext& ctx) const {
   auto& scope = ctx.scope();
   int data_type = -1;
@@ -595,7 +595,7 @@ proto::DataType OperatorWithKernel::IndicateDataType(
     }
   }
   PADDLE_ENFORCE(data_type != -1, "DataType should be indicated by input");
-  return static_cast<proto::DataType>(data_type);
+  return static_cast<proto::VarType::Type>(data_type);
 }
 
 OpKernelType OperatorWithKernel::GetExpectedKernelType(

paddle/fluid/framework/operator.h

@@ -394,9 +394,9 @@ class OperatorWithKernel : public OperatorBase {
       const OpKernelType& expected_kernel_type) const;
 
  private:
-  // indicate kernel DataType by input data. Defaultly all input data must be
+  // indicate kernel DataType by input data. By default all input data must be
   // same.
-  proto::DataType IndicateDataType(const ExecutionContext& ctx) const;
+  proto::VarType::Type IndicateDataType(const ExecutionContext& ctx) const;
   void RunImpl(const Scope& scope, const platform::Place& place) const final;
 };
 

paddle/fluid/framework/operator_test.cc

@@ -119,7 +119,7 @@ class OpWithKernelTest : public OperatorWithKernel {
   void InferShape(framework::InferShapeContext* ctx) const override {}
   OpKernelType GetExpectedKernelType(
       const ExecutionContext& ctx) const override {
-    return OpKernelType(proto::DataType::FP32, ctx.GetPlace());
+    return OpKernelType(proto::VarType::FP32, ctx.GetPlace());
   }
 };
 

paddle/fluid/framework/program_desc_test.cc

@@ -24,13 +24,13 @@ TEST(ProgramDesc, copy_ctor) {
   auto* x = global_block->Var("X");
   x->SetType(proto::VarType::LOD_TENSOR);
   x->SetLoDLevel(0);
-  x->SetDataType(proto::FP32);
+  x->SetDataType(proto::VarType::FP32);
   x->SetShape({1000, 784});
 
   auto* y = global_block->Var("Y");
   y->SetType(proto::VarType::LOD_TENSOR);
   y->SetLoDLevel(0);
-  y->SetDataType(proto::FP32);
+  y->SetDataType(proto::VarType::FP32);
   y->SetShape({784, 100});
 
   auto* op = global_block->AppendOp();
@@ -86,13 +86,13 @@ TEST(ProgramDescBind, serialize_and_deserialize) {
   auto* x = global_block->Var("X");
   x->SetType(proto::VarType::LOD_TENSOR);
   x->SetLoDLevel(0);
-  x->SetDataType(proto::FP32);
+  x->SetDataType(proto::VarType::FP32);
   x->SetShape({1000, 784});
 
   auto* y = global_block->Var("Y");
   y->SetType(proto::VarType::LOD_TENSOR);
   y->SetLoDLevel(0);
-  y->SetDataType(proto::FP32);
+  y->SetDataType(proto::VarType::FP32);
   y->SetShape({784, 100});
 
   auto* op = global_block->AppendOp();

paddle/fluid/framework/prune_test.cc

@@ -34,7 +34,7 @@ void AddOp(const std::string &type, const f::VariableNameMap &inputs,
   for (auto kv : outputs) {
     for (auto v : kv.second) {
       auto var = block->Var(v);
-      var->SetDataType(paddle::framework::proto::DataType::FP32);
+      var->SetDataType(paddle::framework::proto::VarType::FP32);
     }
   }