PaddlePaddle
diff --git a/‎.clang-tidy
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎.clang-tidy
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/distributed/auto_parallel/spmd_rules/common.cc
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions b/‎paddle/fluid/distributed/auto_parallel/spmd_rules/common.cc
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions
diff --git a/‎paddle/fluid/distributed/collective/reducer.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/distributed/collective/reducer.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/distributed/ps/table/graph/graph_node.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/distributed/ps/table/graph/graph_node.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/distributed/ps/table/ssd_sparse_table.cc
Copy file name to clipboard
+9-10Lines changed: 9 additions & 10 deletions b/‎paddle/fluid/distributed/ps/table/ssd_sparse_table.cc
Copy file name to clipboard
+9-10Lines changed: 9 additions & 10 deletions
diff --git a/‎paddle/fluid/framework/attribute_test.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/framework/attribute_test.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/framework/data_feed.cc
Copy file name to clipboard
+10-10Lines changed: 10 additions & 10 deletions b/‎paddle/fluid/framework/data_feed.cc
Copy file name to clipboard
+10-10Lines changed: 10 additions & 10 deletions
diff --git a/‎paddle/fluid/framework/data_set.cc
Copy file name to clipboard
+9-9Lines changed: 9 additions & 9 deletions b/‎paddle/fluid/framework/data_set.cc
Copy file name to clipboard
+9-9Lines changed: 9 additions & 9 deletions
diff --git a/‎paddle/fluid/framework/dist_multi_trainer.cc
Copy file name to clipboard
+4-5Lines changed: 4 additions & 5 deletions b/‎paddle/fluid/framework/dist_multi_trainer.cc
Copy file name to clipboard
+4-5Lines changed: 4 additions & 5 deletions
diff --git a/‎paddle/fluid/framework/downpour_worker.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/framework/downpour_worker.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -180,7 +180,7 @@ modernize-redundant-void-arg,
 -modernize-shrink-to-fit,
 -modernize-unary-static-assert,
 -modernize-use-bool-literals,
--modernize-use-emplace,
+modernize-use-emplace,
 -modernize-use-equals-default,
 -modernize-use-equals-delete,
 -modernize-use-noexcept,
 
@@ -203,8 +203,7 @@ GetAxesDimsMappingPair(const std::vector<std::string>& tensor_axes,
   std::vector<std::pair<std::string, std::vector<int64_t>>> res;
   size_t ntensor = specs.size();
   for (size_t i = 0; i < ntensor; ++i) {
-    res.emplace_back(std::pair<std::string, std::vector<int64_t>>(
-        tensor_axes[i], specs[i].dims_mapping()));
+    res.emplace_back(tensor_axes[i], specs[i].dims_mapping());
   }
   return res;
 }
 
@@ -609,8 +609,8 @@ void EagerReducer::InitializeDenseGroups(
     p_group->length_.push_back(size);
 
     // for concat operator
-    p_group->origin_shapes_.push_back(IntArray(tensor.shape()));
-    p_group->dense_tensors_.push_back(phi::DenseTensor());
+    p_group->origin_shapes_.emplace_back(tensor.shape());
+    p_group->dense_tensors_.emplace_back();
 
     const auto &dtype = tensor.dtype();
     const auto &inner_place = tensor.impl()->place();
 
@@ -114,7 +114,7 @@ void FeatureNode::recover_from_buffer(char* buffer) {
     memcpy(str, buffer, feat_len);
     buffer += feat_len;
     str[feat_len] = '\0';
-    feature.push_back(std::string(str));
+    feature.push_back(str);  // NOLINT
   }
 }
 }  // namespace distributed
 
@@ -88,7 +88,7 @@ int32_t SSDSparseTable::PullSparse(float* pull_values,
         _real_local_shard_num);
     for (size_t i = 0; i < num; ++i) {
       int shard_id = (keys[i] % _sparse_table_shard_num) % _avg_local_shard_num;
-      task_keys[shard_id].push_back({keys[i], i});
+      task_keys[shard_id].emplace_back(keys[i], i);
     }
 
     std::atomic<uint32_t> missed_keys{0};
@@ -202,8 +202,8 @@ int32_t SSDSparseTable::PullSparsePtr(int shard_id,
       auto itr = local_shard.find(key);
       if (itr == local_shard.end()) {
         cur_ctx->batch_index.push_back(i);
-        cur_ctx->batch_keys.push_back(rocksdb::Slice(
-            (char*)&(pull_keys[i]), sizeof(uint64_t)));  // NOLINT
+        cur_ctx->batch_keys.emplace_back(
+            reinterpret_cast<const char*>(&(pull_keys[i])), sizeof(uint64_t));
         if (cur_ctx->batch_keys.size() == 1024) {
           cur_ctx->batch_values.resize(cur_ctx->batch_keys.size());
           cur_ctx->status.resize(cur_ctx->batch_keys.size());
@@ -334,7 +334,7 @@ int32_t SSDSparseTable::PushSparse(const uint64_t* keys,
         _real_local_shard_num);
     for (size_t i = 0; i < num; ++i) {
       int shard_id = (keys[i] % _sparse_table_shard_num) % _avg_local_shard_num;
-      task_keys[shard_id].push_back({keys[i], i});
+      task_keys[shard_id].emplace_back(keys[i], i);
     }
     for (int shard_id = 0; shard_id < _real_local_shard_num; ++shard_id) {
       tasks[shard_id] =
@@ -440,7 +440,7 @@ int32_t SSDSparseTable::PushSparse(const uint64_t* keys,
         _real_local_shard_num);
     for (size_t i = 0; i < num; ++i) {
       int shard_id = (keys[i] % _sparse_table_shard_num) % _avg_local_shard_num;
-      task_keys[shard_id].push_back({keys[i], i});
+      task_keys[shard_id].emplace_back(keys[i], i);
     }
     for (int shard_id = 0; shard_id < _real_local_shard_num; ++shard_id) {
       tasks[shard_id] =
@@ -1658,11 +1658,10 @@ int32_t SSDSparseTable::LoadWithString(
         // ssd or mem
         if (_value_accesor->SaveSSD(data_buffer_ptr)) {
           tmp_key.emplace_back(key);
-          ssd_keys.emplace_back(std::make_pair(
-              reinterpret_cast<char*>(&tmp_key.back()), sizeof(uint64_t)));
-          ssd_values.emplace_back(
-              std::make_pair(reinterpret_cast<char*>(data_buffer_ptr),
-                             value_size * sizeof(float)));
+          ssd_keys.emplace_back(reinterpret_cast<char*>(&tmp_key.back()),
+                                sizeof(uint64_t));
+          ssd_values.emplace_back(reinterpret_cast<char*>(data_buffer_ptr),
+                                  value_size * sizeof(float));
           data_buffer_ptr += feature_value_size;
           if (static_cast<int>(ssd_keys.size()) ==
               FLAGS_pserver_load_batch_size) {
 
@@ -297,7 +297,7 @@ TEST(Attribute, ProtoAttrToAttribute_scalars) {
 
   std::vector<paddle::experimental::Scalar> scalars;
   for (int i = 0; i < 10; i++) {
-    scalars.push_back(paddle::experimental::Scalar(i));
+    scalars.emplace_back(i);
   }
   std::vector<paddle::framework::proto::Scalar> proto_scalars;
   proto_scalars.reserve(scalars.size());
 
@@ -1084,13 +1084,13 @@ void MultiSlotInMemoryDataFeed::Init(
   feed_vec_.resize(use_slots_.size());
   const int kEstimatedFeasignNumPerSlot = 5;  // Magic Number
   for (size_t i = 0; i < all_slot_num; i++) {
-    batch_float_feasigns_.push_back(std::vector<float>());
-    batch_uint64_feasigns_.push_back(std::vector<uint64_t>());
+    batch_float_feasigns_.emplace_back();
+    batch_uint64_feasigns_.emplace_back();
     batch_float_feasigns_[i].reserve(default_batch_size_ *
                                      kEstimatedFeasignNumPerSlot);
     batch_uint64_feasigns_[i].reserve(default_batch_size_ *
                                       kEstimatedFeasignNumPerSlot);
-    offset_.push_back(std::vector<size_t>());
+    offset_.emplace_back();
     offset_[i].reserve(default_batch_size_ +
                        1);  // Each lod info will prepend a zero
   }
@@ -1224,7 +1224,7 @@ bool MultiSlotInMemoryDataFeed::ParseOneInstanceFromPipe(Record* instance) {
             }
             FeatureFeasign f;
             f.float_feasign_ = feasign;
-            instance->float_feasigns_.push_back(FeatureItem(f, idx));
+            instance->float_feasigns_.emplace_back(f, idx);
           }
         } else if (all_slots_type_[i][0] == 'u') {  // uint64
           for (int j = 0; j < num; ++j) {
@@ -1236,7 +1236,7 @@ bool MultiSlotInMemoryDataFeed::ParseOneInstanceFromPipe(Record* instance) {
             }
             FeatureFeasign f;
             f.uint64_feasign_ = feasign;
-            instance->uint64_feasigns_.push_back(FeatureItem(f, idx));
+            instance->uint64_feasigns_.emplace_back(f, idx);
           }
         }
         pos = endptr - str;
@@ -1297,7 +1297,7 @@ bool MultiSlotInMemoryDataFeed::ParseOneInstance(Record* instance) {
             }
             FeatureFeasign f;
             f.float_feasign_ = feasign;
-            instance->float_feasigns_.push_back(FeatureItem(f, idx));
+            instance->float_feasigns_.emplace_back(f, idx);
           }
         } else if (all_slots_type_[i][0] == 'u') {  // uint64
           for (int j = 0; j < num; ++j) {
@@ -1307,7 +1307,7 @@ bool MultiSlotInMemoryDataFeed::ParseOneInstance(Record* instance) {
             }
             FeatureFeasign f;
             f.uint64_feasign_ = feasign;
-            instance->uint64_feasigns_.push_back(FeatureItem(f, idx));
+            instance->uint64_feasigns_.emplace_back(f, idx);
           }
         }
         pos = endptr - str;
@@ -2093,13 +2093,13 @@ void SlotRecordInMemoryDataFeed::Init(const DataFeedDesc& data_feed_desc) {
   feed_vec_.resize(used_slots_info_.size());
   const int kEstimatedFeasignNumPerSlot = 5;  // Magic Number
   for (size_t i = 0; i < all_slot_num; i++) {
-    batch_float_feasigns_.push_back(std::vector<float>());
-    batch_uint64_feasigns_.push_back(std::vector<uint64_t>());
+    batch_float_feasigns_.emplace_back();
+    batch_uint64_feasigns_.emplace_back();
     batch_float_feasigns_[i].reserve(default_batch_size_ *
                                      kEstimatedFeasignNumPerSlot);
     batch_uint64_feasigns_[i].reserve(default_batch_size_ *
                                       kEstimatedFeasignNumPerSlot);
-    offset_.push_back(std::vector<size_t>());
+    offset_.emplace_back();
     offset_[i].reserve(default_batch_size_ +
                        1);  // Each lod info will prepend a zero
   }
 
@@ -510,8 +510,8 @@ void DatasetImpl<T>::LoadIntoMemory() {
 #endif
   } else {
     for (int64_t i = 0; i < thread_num_; ++i) {
-      load_threads.push_back(std::thread(
-          &paddle::framework::DataFeed::LoadIntoMemory, readers_[i].get()));
+      load_threads.emplace_back(&paddle::framework::DataFeed::LoadIntoMemory,
+                                readers_[i].get());
     }
     for (std::thread& t : load_threads) {
       t.join();
@@ -534,16 +534,16 @@ void DatasetImpl<T>::PreLoadIntoMemory() {
     CHECK(static_cast<size_t>(preload_thread_num_) == preload_readers_.size());
     preload_threads_.clear();
     for (int64_t i = 0; i < preload_thread_num_; ++i) {
-      preload_threads_.push_back(
-          std::thread(&paddle::framework::DataFeed::LoadIntoMemory,
-                      preload_readers_[i].get()));
+      preload_threads_.emplace_back(
+          &paddle::framework::DataFeed::LoadIntoMemory,
+          preload_readers_[i].get());
     }
   } else {
     CHECK(static_cast<size_t>(thread_num_) == readers_.size());
     preload_threads_.clear();
     for (int64_t i = 0; i < thread_num_; ++i) {
-      preload_threads_.push_back(std::thread(
-          &paddle::framework::DataFeed::LoadIntoMemory, readers_[i].get()));
+      preload_threads_.emplace_back(
+          &paddle::framework::DataFeed::LoadIntoMemory, readers_[i].get());
     }
   }
   VLOG(3) << "DatasetImpl<T>::PreLoadIntoMemory() end";
@@ -849,7 +849,7 @@ void MultiSlotDataset::GlobalShuffle(int thread_num) {
   }
   VLOG(3) << "start global shuffle threads, num = " << thread_num;
   for (int i = 0; i < thread_num; ++i) {
-    global_shuffle_threads.push_back(std::thread(global_shuffle_func));
+    global_shuffle_threads.emplace_back(global_shuffle_func);
   }
   for (std::thread& t : global_shuffle_threads) {
     t.join();
@@ -1618,7 +1618,7 @@ void MultiSlotDataset::GetRandomData(
     for (auto slot : slots_to_replace) {
       auto range = rand_rec.feas_.equal_range(slot);
       for (auto it = range.first; it != range.second; ++it) {
-        new_rec.uint64_feasigns_.push_back({it->second, it->first});
+        new_rec.uint64_feasigns_.emplace_back(it->second, it->first);
         debug_push_cnt += 1;
       }
     }
 
@@ -88,7 +88,7 @@ void DistMultiTrainer::InitDumpEnv() {
     }
   }
   for (int i = 0; i < dump_thread_num_; i++) {
-    dump_thread_.push_back(std::thread([this, i] { DumpWork(i); }));
+    dump_thread_.emplace_back([this, i] { DumpWork(i); });
   }
 }
 
@@ -131,11 +131,10 @@ void DistMultiTrainer::InitOtherEnv(const ProgramDesc &main_program) {
 void DistMultiTrainer::Run() {
   for (int thidx = 0; thidx < thread_num_; ++thidx) {
     if (!debug_) {
-      threads_.push_back(
-          std::thread(&DeviceWorker::TrainFiles, workers_[thidx].get()));
+      threads_.emplace_back(&DeviceWorker::TrainFiles, workers_[thidx].get());
     } else {
-      threads_.push_back(std::thread(&DeviceWorker::TrainFilesWithProfiler,
-                                     workers_[thidx].get()));
+      threads_.emplace_back(&DeviceWorker::TrainFilesWithProfiler,
+                            workers_[thidx].get());
     }
   }
 }
 
@@ -107,14 +107,14 @@ void DownpourWorker::Initialize(const TrainerDesc& desc) {
     uint64_t dest_table = copy_table_config_.dest_sparse_tables(i);
     VLOG(3) << "copy_sparse_tables_ push back " << src_table << "->"
             << dest_table;
-    copy_sparse_tables_.push_back(std::make_pair(src_table, dest_table));
+    copy_sparse_tables_.emplace_back(src_table, dest_table);
   }
   for (int i = 0; i < copy_table_config_.src_dense_tables_size(); ++i) {
     uint64_t src_table = copy_table_config_.src_dense_tables(i);
     uint64_t dest_table = copy_table_config_.dest_dense_tables(i);
     VLOG(3) << "copy_dense_tables_ push back " << src_table << "->"
             << dest_table;
-    copy_dense_tables_.push_back(std::make_pair(src_table, dest_table));
+    copy_dense_tables_.emplace_back(src_table, dest_table);
   }
   for (auto& m : copy_table_config_.table_denpendency_map()) {
     if (sparse_key_names_.find(m.key()) != sparse_key_names_.end()) {
Original file line number	Diff line number	Diff line change
`@@ -203,8 +203,7 @@ GetAxesDimsMappingPair(const std::vector<std::string>& tensor_axes,`
`203`	`203`	`std::vector<std::pair<std::string, std::vector<int64_t>>> res;`
`204`	`204`	`size_t ntensor = specs.size();`
`205`	`205`	`for (size_t i = 0; i < ntensor; ++i) {`
`206`		`- res.emplace_back(std::pair<std::string, std::vector<int64_t>>(`
`207`		`- tensor_axes[i], specs[i].dims_mapping()));`
	`206`	`+ res.emplace_back(tensor_axes[i], specs[i].dims_mapping());`
`208`	`207`	`}`
`209`	`208`	`return res;`
`210`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ void FeatureNode::recover_from_buffer(char* buffer) {`
`114`	`114`	`memcpy(str, buffer, feat_len);`
`115`	`115`	`buffer += feat_len;`
`116`	`116`	`str[feat_len] = '\0';`
`117`		`- feature.push_back(std::string(str));`
	`117`	`+ feature.push_back(str); // NOLINT`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`	`} // namespace distributed`
Original file line number	Diff line number	Diff line change
`@@ -297,7 +297,7 @@ TEST(Attribute, ProtoAttrToAttribute_scalars) {`
`297`	`297`
`298`	`298`	`std::vector<paddle::experimental::Scalar> scalars;`
`299`	`299`	`for (int i = 0; i < 10; i++) {`
`300`		`- scalars.push_back(paddle::experimental::Scalar(i));`
	`300`	`+ scalars.emplace_back(i);`
`301`	`301`	`}`
`302`	`302`	`std::vector<paddle::framework::proto::Scalar> proto_scalars;`
`303`	`303`	`proto_scalars.reserve(scalars.size());`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ void DistMultiTrainer::InitDumpEnv() {`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`for (int i = 0; i < dump_thread_num_; i++) {`
`91`		`- dump_thread_.push_back(std::thread([this, i] { DumpWork(i); }));`
	`91`	`+ dump_thread_.emplace_back([this, i] { DumpWork(i); });`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`@@ -131,11 +131,10 @@ void DistMultiTrainer::InitOtherEnv(const ProgramDesc &main_program) {`
`131`	`131`	`void DistMultiTrainer::Run() {`
`132`	`132`	`for (int thidx = 0; thidx < thread_num_; ++thidx) {`
`133`	`133`	`if (!debug_) {`
`134`		`- threads_.push_back(`
`135`		`- std::thread(&DeviceWorker::TrainFiles, workers_[thidx].get()));`
	`134`	`+ threads_.emplace_back(&DeviceWorker::TrainFiles, workers_[thidx].get());`
`136`	`135`	`} else {`
`137`		`- threads_.push_back(std::thread(&DeviceWorker::TrainFilesWithProfiler,`
`138`		`- workers_[thidx].get()));`
	`136`	`+ threads_.emplace_back(&DeviceWorker::TrainFilesWithProfiler,`
	`137`	`+ workers_[thidx].get());`
`139`	`138`	`}`
`140`	`139`	`}`
`141`	`140`	`}`