PaddlePaddle
diff --git a/‎paddle/fluid/distributed/ps/table/ctr_double_accessor.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/fluid/distributed/ps/table/ctr_double_accessor.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/fluid/distributed/ps/table/graph/graph_node.h
Copy file name to clipboard
+22-22Lines changed: 22 additions & 22 deletions b/‎paddle/fluid/distributed/ps/table/graph/graph_node.h
Copy file name to clipboard
+22-22Lines changed: 22 additions & 22 deletions
diff --git a/‎paddle/fluid/distributed/ps/table/memory_sparse_table.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎paddle/fluid/distributed/ps/table/memory_sparse_table.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎paddle/fluid/distributed/ps/table/sparse_sgd_rule.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎paddle/fluid/distributed/ps/table/sparse_sgd_rule.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
diff --git a/‎paddle/fluid/distributed/ps/wrapper/fleet.cc
Copy file name to clipboard
+24-24Lines changed: 24 additions & 24 deletions b/‎paddle/fluid/distributed/ps/wrapper/fleet.cc
Copy file name to clipboard
+24-24Lines changed: 24 additions & 24 deletions
diff --git a/‎paddle/fluid/framework/downpour_lite_worker.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/fluid/framework/downpour_lite_worker.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
@@ -205,9 +205,9 @@ class CtrDoubleAccessor : public ValueAccessor {
   float GetField(float* value, const std::string& name) override {
     PADDLE_ENFORCE_EQ(name,
                       "show",
-                      phi::errors::InvalidArgument("name must be 'show', "
-                                                   "but received '%s'",
-                                                   name.c_str()));
+                      common::errors::InvalidArgument("name must be 'show', "
+                                                      "but received '%s'",
+                                                      name.c_str()));
     if (name == "show") {
       return static_cast<float>(CtrDoubleFeatureValue::Show(value));
     }
 
@@ -143,7 +143,7 @@ class FeatureNode : public Node {
       size_t num = feature_item.length() / sizeof(uint64_t);
       PADDLE_ENFORCE_EQ((feature_item.length() % sizeof(uint64_t)),
                         0,
-                        phi::errors::PreconditionNotMet(
+                        common::errors::PreconditionNotMet(
                             "bad feature_item: [%s]", feature_item.c_str()));
       size_t n = res->size();
       res->resize(n + num);
@@ -170,10 +170,10 @@ class FeatureNode : public Node {
       const uint64_t *feas = (const uint64_t *)(s.c_str());
 
       size_t num = s.length() / sizeof(uint64_t);
-      PADDLE_ENFORCE_EQ(
-          (s.length() % sizeof(uint64_t)),
-          0,
-          phi::errors::PreconditionNotMet("bad feature_item: [%s]", s.c_str()));
+      PADDLE_ENFORCE_EQ((s.length() % sizeof(uint64_t)),
+                        0,
+                        common::errors::PreconditionNotMet(
+                            "bad feature_item: [%s]", s.c_str()));
       res->resize(num);
       for (size_t i = 0; i < num; ++i) {
         (*res)[i] = feas[i];
@@ -196,10 +196,10 @@ class FeatureNode : public Node {
       const std::string &s = this->feature[slot_idx];
       const uint64_t *feas = (const uint64_t *)(s.c_str());
       num = s.length() / sizeof(uint64_t);
-      PADDLE_ENFORCE_EQ(
-          (s.length() % sizeof(uint64_t)),
-          0,
-          phi::errors::PreconditionNotMet("bad feature_item: [%s]", s.c_str()));
+      PADDLE_ENFORCE_EQ((s.length() % sizeof(uint64_t)),
+                        0,
+                        common::errors::PreconditionNotMet(
+                            "bad feature_item: [%s]", s.c_str()));
       for (size_t i = 0; i < num; ++i) {
         feature_id.push_back(feas[i]);
         slot_id.push_back(slot_idx);
@@ -347,7 +347,7 @@ class FloatFeatureNode : public FeatureNode {
       size_t num = feature_item.length() / sizeof(uint64_t);
       PADDLE_ENFORCE_EQ((feature_item.length() % sizeof(uint64_t)),
                         0,
-                        phi::errors::PreconditionNotMet(
+                        common::errors::PreconditionNotMet(
                             "bad feature_item: [%s]", feature_item.c_str()));
       size_t n = res->size();
       res->resize(n + num);
@@ -374,10 +374,10 @@ class FloatFeatureNode : public FeatureNode {
       const uint64_t *feas = (const uint64_t *)(s.c_str());
 
       size_t num = s.length() / sizeof(uint64_t);
-      PADDLE_ENFORCE_EQ(
-          (s.length() % sizeof(uint64_t)),
-          0,
-          phi::errors::PreconditionNotMet("bad feature_item: [%s]", s.c_str()));
+      PADDLE_ENFORCE_EQ((s.length() % sizeof(uint64_t)),
+                        0,
+                        common::errors::PreconditionNotMet(
+                            "bad feature_item: [%s]", s.c_str()));
       res->resize(num);
       for (size_t i = 0; i < num; ++i) {
         (*res)[i] = feas[i];
@@ -400,10 +400,10 @@ class FloatFeatureNode : public FeatureNode {
       const std::string &s = this->feature[slot_idx];
       const uint64_t *feas = (const uint64_t *)(s.c_str());
       num = s.length() / sizeof(uint64_t);
-      PADDLE_ENFORCE_EQ(
-          (s.length() % sizeof(uint64_t)),
-          0,
-          phi::errors::PreconditionNotMet("bad feature_item: [%s]", s.c_str()));
+      PADDLE_ENFORCE_EQ((s.length() % sizeof(uint64_t)),
+                        0,
+                        common::errors::PreconditionNotMet(
+                            "bad feature_item: [%s]", s.c_str()));
       for (size_t i = 0; i < num; ++i) {
         feature_id.push_back(feas[i]);
         slot_id.push_back(slot_idx);
@@ -428,10 +428,10 @@ class FloatFeatureNode : public FeatureNode {
       const std::string &s = this->feature[float_feature_start_idx + slot_idx];
       const float *feas = (const float *)(s.c_str());
       num = s.length() / sizeof(float);
-      PADDLE_ENFORCE_EQ(
-          (s.length() % sizeof(float)),
-          0,
-          phi::errors::PreconditionNotMet("bad feature_item: [%s]", s.c_str()));
+      PADDLE_ENFORCE_EQ((s.length() % sizeof(float)),
+                        0,
+                        common::errors::PreconditionNotMet(
+                            "bad feature_item: [%s]", s.c_str()));
       for (size_t i = 0; i < num; ++i) {
         float_feature.push_back(feas[i]);
         slot_id.push_back(slot_idx);
 
@@ -88,7 +88,7 @@ int32_t MemorySparseTable::InitializeValue() {
     PADDLE_ENFORCE_LE(
         _m_avg_local_shard_num,
         _avg_local_shard_num,
-        phi::errors::InvalidArgument(
+        common::errors::InvalidArgument(
             "The calculated '_m_avg_local_shard_num' (%d) must be less than or "
             "equal to '_avg_local_shard_num' (%d).",
             _m_avg_local_shard_num,
@@ -99,7 +99,7 @@ int32_t MemorySparseTable::InitializeValue() {
     PADDLE_ENFORCE_LE(
         _m_real_local_shard_num,
         _real_local_shard_num,
-        phi::errors::InvalidArgument(
+        common::errors::InvalidArgument(
             "The calculated '_m_real_local_shard_num' (%d) must be less than "
             "or equal to '_real_local_shard_num' (%d).",
             _m_real_local_shard_num,
@@ -966,7 +966,7 @@ int32_t MemorySparseTable::Pull(TableContext &context) {
   PADDLE_ENFORCE_EQ(
       context.value_type,
       Sparse,
-      phi::errors::InvalidArgument(
+      common::errors::InvalidArgument(
           "The 'value_type' in context must be 'Sparse', but received %d.",
           context.value_type));
   if (context.use_ptr) {
@@ -985,7 +985,7 @@ int32_t MemorySparseTable::Push(TableContext &context) {
   PADDLE_ENFORCE_EQ(
       context.value_type,
       Sparse,
-      phi::errors::InvalidArgument(
+      common::errors::InvalidArgument(
           "The 'value_type' in context must be 'Sparse', but received %d.",
           context.value_type));
   if (!context.use_ptr) {
 
@@ -36,7 +36,7 @@ void SparseNaiveSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
   } else {
     PADDLE_ENFORCE_GE(naive_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           naive_param.weight_bounds_size()));
     _min_bound = naive_param.weight_bounds(0);
@@ -85,7 +85,7 @@ void SparseAdaGradSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
   } else {
     PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
@@ -144,7 +144,7 @@ void StdAdaGradSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
   } else {
     PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
@@ -200,7 +200,7 @@ void SparseAdamSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
   } else {
     PADDLE_ENFORCE_GE(adam_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           adam_param.weight_bounds_size()));
     _min_bound = adam_param.weight_bounds(0);
@@ -276,7 +276,7 @@ void SparseSharedAdamSGDRule::LoadConfig(
   } else {
     PADDLE_ENFORCE_GE(adam_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           adam_param.weight_bounds_size()));
     _min_bound = adam_param.weight_bounds(0);
@@ -360,7 +360,7 @@ void SparseAdaGradV2SGDRule::LoadConfig(
   } else {
     PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
                       2,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "invalid repeated size for weight_bounds: %d",
                           adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
 
@@ -228,7 +228,7 @@ std::future<int32_t> FleetWrapper::PullSparseVarsAsync(
     phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
     PADDLE_ENFORCE_NOT_NULL(
         tensor,
-        phi::errors::InvalidArgument(
+        common::errors::InvalidArgument(
             "Tensor of var %s is null. It must not be null.", name));
     int64_t* ids = tensor->data<int64_t>();
     size_t len = tensor->numel();
@@ -278,7 +278,7 @@ void FleetWrapper::PullSparseVarsSync(
     phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
     PADDLE_ENFORCE_NOT_NULL(
         tensor,
-        phi::errors::InvalidArgument(
+        common::errors::InvalidArgument(
             "Tensor of var %s is null. It must not be null.", name));
     int64_t* ids = tensor->data<int64_t>();
     size_t len = tensor->numel();
@@ -353,7 +353,7 @@ void FleetWrapper::PullSparseToTensorSync(
         PADDLE_ENFORCE_LT(
             output_index,
             outputs->size(),
-            phi::errors::InvalidArgument(
+            common::errors::InvalidArgument(
                 "The output_index (%d) is out of bounds for outputs size (%d).",
                 output_index,
                 outputs->size()));
@@ -363,14 +363,14 @@ void FleetWrapper::PullSparseToTensorSync(
         output_len = 0;
         PADDLE_ENFORCE_EQ(output->numel() % fea_dim,
                           0,
-                          phi::errors::InvalidArgument(
+                          common::errors::InvalidArgument(
                               "The total number of elements (%d) is not "
                               "divisible by feature dimension (%d).",
                               output->numel(),
                               fea_dim));
         PADDLE_ENFORCE_NOT_NULL(
             output_data,
-            phi::errors::InvalidArgument(
+            common::errors::InvalidArgument(
                 "output_data is null. It must not be null."));
       }
       uint64_t real_id = static_cast<uint64_t>(ids[i]);
@@ -452,7 +452,7 @@ void FleetWrapper::PushDenseParamSync(
   for (auto& t : var_names) {
     Variable* var = scope.FindVar(t);
     PADDLE_ENFORCE_NOT_NULL(
-        var, phi::errors::InvalidArgument("var[%s] not found", t));
+        var, common::errors::InvalidArgument("var[%s] not found", t));
     phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
     if (!phi::is_gpu_place(tensor->place())) {
       float* g = tensor->mutable_data<float>(place);
@@ -466,7 +466,7 @@ void FleetWrapper::PushDenseParamSync(
   auto status = push_status.get();
   PADDLE_ENFORCE_EQ(status,
                     0,
-                    phi::errors::InvalidArgument(
+                    common::errors::InvalidArgument(
                         "push dense param failed, status[%d]", status));
 }
 
@@ -487,7 +487,7 @@ void FleetWrapper::PushDenseVarsAsync(
   for (auto& t : var_names) {
     Variable* var = scope.FindVar(t);
     PADDLE_ENFORCE_NOT_NULL(
-        var, phi::errors::InvalidArgument("var[%s] not found", t));
+        var, common::errors::InvalidArgument("var[%s] not found", t));
     phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
     int count = tensor->numel();
     float* g = tensor->mutable_data<float>(place);
@@ -583,7 +583,7 @@ void FleetWrapper::PushSparseFromTensorAsync(
     bool use_cvm_op) {
   PADDLE_ENFORCE_EQ(slots.size(),
                     inputs->size(),
-                    phi::errors::InvalidArgument(
+                    common::errors::InvalidArgument(
                         "The size of slots and inputs must be the same. "
                         "Got slots.size() = %d, inputs->size() = %d.",
                         slots.size(),
@@ -601,17 +601,17 @@ void FleetWrapper::PushSparseFromTensorAsync(
       break;
     }
   }
-  PADDLE_ENFORCE_GT(
-      batch_size,
-      0,
-      phi::errors::InvalidArgument("The batch size must be greater than 0."));
+  PADDLE_ENFORCE_GT(batch_size,
+                    0,
+                    common::errors::InvalidArgument(
+                        "The batch size must be greater than 0."));
 
   size_t show_size =
       !shows->lod().empty() ? shows->lod()[0].size() - 1 : shows->dims()[0];
   if (show_size != size_t(batch_size))
     PADDLE_ENFORCE_EQ(show_size,
                       1,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "The show_size must be either equal to the "
                           "batch_size as size_t (%d) or equal to 1 (got %d).",
                           batch_size,
@@ -621,14 +621,14 @@ void FleetWrapper::PushSparseFromTensorAsync(
   if (show_size != size_t(batch_size))
     PADDLE_ENFORCE_EQ(show_size,
                       1,
-                      phi::errors::InvalidArgument(
+                      common::errors::InvalidArgument(
                           "The show_size must be either equal to the "
                           "batch_size as size_t (%d) or equal to 1 (got %d).",
                           batch_size,
                           show_size));
   PADDLE_ENFORCE_EQ(outputs->size(),
                     inputs->size(),
-                    phi::errors::InvalidArgument(
+                    common::errors::InvalidArgument(
                         "The size of outputs and inputs must be the same. "
                         "Got outputs->size() = %d, inputs->size() = %d.",
                         outputs->size(),
@@ -723,11 +723,11 @@ void FleetWrapper::PushSparseFromTensorAsync(
         ++input_idx;
       }
     }
-    PADDLE_ENFORCE_EQ(
-        static_cast<int64_t>(output_len),
-        g_tensor->numel(),
-        phi::errors::InvalidArgument("The casted output length must equal the "
-                                     "number of elements in the tensor."));
+    PADDLE_ENFORCE_EQ(static_cast<int64_t>(output_len),
+                      g_tensor->numel(),
+                      common::errors::InvalidArgument(
+                          "The casted output length must equal the "
+                          "number of elements in the tensor."));
   }
 
   std::vector<float*> push_g_vec(input_idx, nullptr);
@@ -839,7 +839,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id,
     if (name.find("batch_sum") != std::string::npos) {
       Variable* var = scope->FindVar(name);
       PADDLE_ENFORCE_NOT_NULL(
-          var, phi::errors::InvalidArgument("var batch_sum not found"));
+          var, common::errors::InvalidArgument("var batch_sum not found"));
       VLOG(3) << "prepare shrink dense batch_sum";
       phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
       float* g = tensor->data<float>();
@@ -850,7 +850,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id,
           size_name.find("batch_sum"), size_name.length(), "batch_size");
       Variable* var_size = scope->FindVar(size_name);
       PADDLE_ENFORCE_NOT_NULL(
-          var_size, phi::errors::InvalidArgument("var batch_sum not found"));
+          var_size, common::errors::InvalidArgument("var batch_sum not found"));
       VLOG(3) << "shrink dense batch_sum: " << name << ", " << size_name;
       float* g_size = var_size->GetMutable<phi::DenseTensor>()->data<float>();
 
@@ -862,7 +862,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id,
     } else {
       Variable* var = scope->FindVar(name);
       PADDLE_ENFORCE_NOT_NULL(
-          var, phi::errors::InvalidArgument("var batch_sum not found"));
+          var, common::errors::InvalidArgument("var batch_sum not found"));
       phi::DenseTensor* tensor = var->GetMutable<phi::DenseTensor>();
       float* g = tensor->data<float>();
       ::paddle::distributed::Region reg(g, tensor->numel());
 
@@ -206,31 +206,31 @@ void DownpourLiteWorker::CopyDenseVars() {
     Variable* src_var = thread_scope_->FindVar(src_var_name);
     PADDLE_ENFORCE_EQ(src_var != nullptr,
                       true,
-                      phi::errors::NotFound("%s not found", src_var_name));
+                      common::errors::NotFound("%s not found", src_var_name));
     phi::DenseTensor* src_tensor = src_var->GetMutable<phi::DenseTensor>();
     PADDLE_ENFORCE_EQ(
         src_tensor != nullptr,
         true,
-        phi::errors::InvalidArgument("%s tensor is null", src_var_name));
+        common::errors::InvalidArgument("%s tensor is null", src_var_name));
     float* src_data = src_tensor->data<float>();
 
     Variable* dest_var = thread_scope_->FindVar(dest_var_name);
     PADDLE_ENFORCE_EQ(dest_var != nullptr,
                       true,
-                      phi::errors::NotFound("%s not found", dest_var_name));
+                      common::errors::NotFound("%s not found", dest_var_name));
     phi::DenseTensor* dest_tensor = dest_var->GetMutable<phi::DenseTensor>();
     PADDLE_ENFORCE_EQ(
         dest_tensor != nullptr,
         true,
-        phi::errors::InvalidArgument("%s tensor is null", dest_var_name));
+        common::errors::InvalidArgument("%s tensor is null", dest_var_name));
     float* dest_data = dest_tensor->data<float>();
 
     PADDLE_ENFORCE_EQ(
         src_tensor->numel(),
         dest_tensor->numel(),
-        phi::errors::InvalidArgument("tensor numel not equal, %d vs %d",
-                                     src_tensor->numel(),
-                                     dest_tensor->numel()));
+        common::errors::InvalidArgument("tensor numel not equal, %d vs %d",
+                                        src_tensor->numel(),
+                                        dest_tensor->numel()));
     for (int i = 0; i < src_tensor->numel(); i++) {
       dest_data[i] = src_data[i];
     }