From 1cb12ff5cbfa27bab810231428f61e28e9365eff Mon Sep 17 00:00:00 2001 From: Chen Weihang Date: Tue, 25 Oct 2022 23:32:28 -0500 Subject: [PATCH] Remove the declaration of using LoDTensor in framework/lod_tensor.h (Part2) (#46953) * remove using lodtensor part2 * resolve code format error * resolve conflict * resolve conflict * replace added frameworrk tensor --- .../framework/data_device_transform_test.cu | 2 +- paddle/fluid/framework/data_feed.cc | 13 ++- paddle/fluid/framework/data_feed.cu | 53 +++++---- paddle/fluid/framework/data_feed.h | 26 ++--- paddle/fluid/framework/data_transform.cc | 9 +- .../framework/details/all_reduce_op_handle.cc | 4 +- .../details/async_ssa_graph_executor.cc | 9 +- .../details/eager_deletion_op_handle.cc | 5 +- .../details/fetch_async_op_handle.cc | 18 +-- .../framework/details/fetch_async_op_handle.h | 4 +- .../framework/details/fetch_op_handle.cc | 18 +-- .../details/fused_all_reduce_op_handle.cc | 20 ++-- .../details/fused_all_reduce_op_handle.h | 16 +-- .../grad_merge_all_reduce_op_handle.cc | 4 +- .../details/parallel_ssa_graph_executor.cc | 12 +- .../framework/details/reduce_and_gather.h | 7 +- .../framework/details/reduce_op_handle.cc | 4 +- .../details/scale_loss_grad_op_handle.cc | 2 +- .../details/scope_buffered_monitor.cc | 5 +- .../scope_buffered_ssa_graph_executor.cc | 2 +- .../details/share_tensor_buffer_functor.h | 12 +- .../details/sparse_all_reduce_op_handle.cc | 21 ++-- .../framework/details/variable_visitor.cc | 18 +-- paddle/fluid/framework/device_worker.cc | 18 +-- paddle/fluid/framework/device_worker.h | 8 +- paddle/fluid/framework/device_worker_test.cc | 16 +-- paddle/fluid/framework/dist_multi_trainer.cc | 9 +- .../fluid/framework/downpour_lite_worker.cc | 10 +- paddle/fluid/framework/downpour_worker.cc | 25 ++-- paddle/fluid/framework/downpour_worker_opt.cc | 2 +- paddle/fluid/framework/executor.cc | 6 +- paddle/fluid/framework/executor.h | 19 +-- paddle/fluid/framework/executor_gc_helper.cc | 5 +- .../fluid/framework/executor_thread_worker.cc | 23 ++-- paddle/fluid/framework/feed_fetch_method.cc | 11 +- paddle/fluid/framework/feed_fetch_method.h | 5 +- paddle/fluid/framework/feed_fetch_type.h | 11 +- paddle/fluid/framework/fleet/box_wrapper.h | 4 +- .../fluid/framework/fleet/box_wrapper_impl.h | 4 +- paddle/fluid/framework/fleet/fleet_wrapper.cc | 63 +++++----- paddle/fluid/framework/fleet/fleet_wrapper.h | 19 +-- paddle/fluid/framework/fleet/heter_wrapper.cc | 6 +- paddle/fluid/framework/fleet/metrics.h | 4 +- paddle/fluid/framework/fleet/nccl_wrapper.cc | 2 +- .../fluid/framework/fleet/ps_gpu_wrapper.cc | 35 +++--- paddle/fluid/framework/fleet/ps_gpu_wrapper.h | 2 +- .../fluid/framework/heter_section_worker.cc | 9 +- paddle/fluid/framework/heter_service.proto | 2 +- paddle/fluid/framework/hetercpu_worker.cc | 42 ++++--- paddle/fluid/framework/heterxpu_trainer.cc | 25 ++-- paddle/fluid/framework/hogwild_worker.cc | 15 +-- paddle/fluid/framework/infershape_utils.cc | 6 +- paddle/fluid/framework/infershape_utils.h | 2 +- .../framework/ir/attention_lstm_fuse_pass.cc | 98 ++++++++-------- .../framework/ir/coalesce_grad_tensor_pass.cc | 9 +- .../framework/ir/constant_folding_pass.cc | 17 +-- .../fluid/framework/ir/conv_bn_fuse_pass.cc | 39 ++++--- .../framework/ir/conv_bn_fuse_pass_tester.cc | 2 +- paddle/fluid/framework/ir/cost_model_test.cc | 2 +- .../ir/delete_fill_constant_op_pass.cc | 6 +- .../ir/delete_quant_dequant_filter_op_pass.cc | 8 +- .../ir/delete_quant_dequant_linear_op_pass.cc | 5 +- .../ir/delete_quant_dequant_op_pass.cc | 4 +- .../delete_weight_dequant_linear_op_pass.cc | 4 +- .../ir/dense_fc_to_sparse_pass_tester.cc | 2 +- ..._multihead_matmul_to_sparse_pass_tester.cc | 2 +- paddle/fluid/framework/ir/fc_fuse_pass.cc | 2 +- .../fluid/framework/ir/fc_fuse_pass_tester.cc | 2 +- paddle/fluid/framework/ir/fc_gru_fuse_pass.cc | 4 +- .../framework/ir/fc_gru_fuse_pass_tester.h | 2 +- .../framework/ir/fc_lstm_fuse_pass_tester.h | 2 +- .../fuse_optimizer_op_pass.cc | 14 +-- ...d_multi_transformer_decoder_pass_tester.cc | 2 +- .../fused_multi_transformer_encoder_pass.cc | 44 +++---- ...d_multi_transformer_encoder_pass_tester.cc | 2 +- .../ir/fusion_group/code_generator_tester.cc | 4 +- .../framework/ir/layer_norm_fuse_pass.cc | 13 ++- .../framework/ir/matmul_scale_fuse_pass.cc | 6 +- .../eager_deletion_pass.cc | 16 +-- .../memory_optimize_pass/memory_reuse_pass.cc | 4 +- .../compute_propagate_scales_mkldnn_pass.cc | 10 +- .../conv_affine_channel_mkldnn_fuse_pass.cc | 14 ++- .../ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc | 12 +- .../conv_bias_mkldnn_fuse_pass_tester.cc | 2 +- .../framework/ir/mkldnn/cpu_quantize_pass.cc | 12 +- .../framework/ir/mkldnn/cpu_quantize_pass.h | 11 +- .../ir/mkldnn/cpu_quantize_pass_tester.cc | 4 +- .../mkldnn/cpu_quantize_squash_pass_tester.cc | 2 +- .../mkldnn/params_quantization_mkldnn_pass.cc | 7 +- .../params_quantization_mkldnn_pass_tester.cc | 8 +- .../ir/mkldnn/quant_dequant_mkldnn_pass.cc | 12 +- ...ranspose_matmul_mkldnn_fuse_pass_tester.cc | 2 +- ...uffle_channel_mkldnn_detect_pass_tester.cc | 2 +- .../ir/multihead_matmul_fuse_pass.cc | 30 +++-- .../ir/multihead_matmul_fuse_pass_tester.cc | 2 +- paddle/fluid/framework/ir/pass_test_util.cc | 2 +- .../ir/quant_conv2d_dequant_fuse_pass.cc | 12 +- .../ir/remove_padding_recover_padding_pass.cc | 5 +- .../ir/trt_multihead_matmul_fuse_pass.cc | 30 +++-- .../framework/ir/vit_attention_fuse_pass.cc | 6 +- paddle/fluid/framework/lod_tensor.cc | 69 +++++------ paddle/fluid/framework/lod_tensor.h | 39 +++---- paddle/fluid/framework/lod_tensor_test.cc | 21 ++-- paddle/fluid/framework/lod_tensor_test.cu | 2 +- paddle/fluid/framework/multi_trainer.cc | 26 +++-- paddle/fluid/framework/naive_executor.cc | 4 +- paddle/fluid/framework/naive_executor.h | 2 +- .../event_garbage_collector.cc | 4 +- .../fast_garbage_collector.cc | 4 +- .../no_event_garbage_collector.cc | 4 +- .../new_executor/interpreter/data_transfer.cc | 6 +- .../interpreter/interpreter_util.cc | 4 +- .../framework/new_executor/interpretercore.cc | 14 +-- .../new_executor/new_executor_defs.cc | 44 +++---- .../new_executor/standalone_executor_test.cc | 10 +- paddle/fluid/framework/op_desc.cc | 6 +- paddle/fluid/framework/operator.cc | 109 +++++++++--------- paddle/fluid/framework/operator.h | 2 +- paddle/fluid/framework/operator_test.cc | 25 ++-- .../framework/paddle2cinn/cinn_cache_key.cc | 4 +- .../framework/paddle2cinn/cinn_cache_key.h | 50 ++++---- .../paddle2cinn/cinn_cache_key_test.cc | 22 ++-- .../framework/paddle2cinn/cinn_compiler.cc | 8 +- .../framework/paddle2cinn/cinn_compiler.h | 8 +- .../paddle2cinn/cinn_compiler_test.cc | 4 +- .../paddle2cinn/cinn_graph_symbolization.h | 4 +- .../cinn_graph_symbolization_test.cc | 16 +-- paddle/fluid/framework/parallel_executor.cc | 19 +-- paddle/fluid/framework/parallel_executor.h | 5 +- paddle/fluid/framework/ps_gpu_trainer.cc | 21 ++-- paddle/fluid/framework/ps_gpu_worker.cc | 2 +- paddle/fluid/framework/pull_dense_worker.cc | 12 +- paddle/fluid/framework/save_load_util.cc | 6 +- paddle/fluid/framework/trainer.h | 20 ++-- paddle/fluid/framework/tuple.h | 2 +- paddle/fluid/framework/unused_var_check.cc | 2 +- paddle/fluid/framework/var_type.h | 2 +- paddle/fluid/framework/var_type_traits.h | 2 +- .../fluid/framework/var_type_traits_test.cc | 2 +- paddle/fluid/framework/variable.h | 16 +-- paddle/fluid/framework/variable_helper.cc | 2 +- .../passes/convert_to_mixed_precision.cc | 2 +- .../ir_params_sync_among_devices_pass.cc | 2 +- .../convert/fused_lookup_tables_op.cc | 2 +- .../tensorrt/convert/merge_layernorm_op.cc | 4 +- .../inference/tensorrt/test_dynamic_engine.cc | 6 +- .../fluid/operators/share_buffer_op_test.cc | 8 +- paddle/fluid/pybind/parallel_executor.cc | 2 +- paddle/fluid/pybind/pybind.cc | 22 ++-- 149 files changed, 979 insertions(+), 885 deletions(-) mode change 100755 => 100644 paddle/fluid/framework/multi_trainer.cc diff --git a/paddle/fluid/framework/data_device_transform_test.cu b/paddle/fluid/framework/data_device_transform_test.cu index 0ecb7fb2f6..777d7a6770 100644 --- a/paddle/fluid/framework/data_device_transform_test.cu +++ b/paddle/fluid/framework/data_device_transform_test.cu @@ -153,7 +153,7 @@ TEST(Operator, CPUtoGPU) { gpu_op->Run(scope, cuda_place); VLOG(3) << "after gpu_op run"; - // auto* output2_ptr = output2->Get().data(); + // auto* output2_ptr = output2->Get().data(); paddle::platform::DeviceContextPool& pool = paddle::platform::DeviceContextPool::Instance(); auto dev_ctx = pool.Get(cuda_place); diff --git a/paddle/fluid/framework/data_feed.cc b/paddle/fluid/framework/data_feed.cc index 4b5177aaa4..660f1838dc 100644 --- a/paddle/fluid/framework/data_feed.cc +++ b/paddle/fluid/framework/data_feed.cc @@ -188,7 +188,7 @@ void DataFeed::AddFeedVar(Variable* var, const std::string& name) { if (var == nullptr) { feed_vec_[i] = nullptr; } else { - feed_vec_[i] = var->GetMutable(); + feed_vec_[i] = var->GetMutable(); } } } @@ -257,7 +257,7 @@ void DataFeed::CheckStart() { void DataFeed::AssignFeedVar(const Scope& scope) { CheckInit(); for (size_t i = 0; i < use_slots_.size(); ++i) { - feed_vec_[i] = scope.FindVar(use_slots_[i])->GetMutable(); + feed_vec_[i] = scope.FindVar(use_slots_[i])->GetMutable(); } } @@ -1889,7 +1889,8 @@ void PaddleBoxDataFeed::AssignFeedVar(const Scope& scope) { // set rank offset memory int phase = GetCurrentPhase(); // join: 1, update: 0 if (enable_pv_merge_ && phase == 1) { - rank_offset_ = scope.FindVar(rank_offset_name_)->GetMutable(); + rank_offset_ = + scope.FindVar(rank_offset_name_)->GetMutable(); } } @@ -2478,7 +2479,7 @@ void SlotRecordInMemoryDataFeed::AssignFeedVar(const Scope& scope) { CheckInit(); for (int i = 0; i < use_slot_size_; ++i) { feed_vec_[i] = - scope.FindVar(used_slots_info_[i].slot)->GetMutable(); + scope.FindVar(used_slots_info_[i].slot)->GetMutable(); } } @@ -2717,8 +2718,8 @@ void SlotRecordInMemoryDataFeed::BuildSlotBatchGPU(const int ins_num) { // alloc gpu memory pack_->resize_tensor(); - LoDTensor& float_tensor = pack_->float_tensor(); - LoDTensor& uint64_tensor = pack_->uint64_tensor(); + phi::DenseTensor& float_tensor = pack_->float_tensor(); + phi::DenseTensor& uint64_tensor = pack_->uint64_tensor(); int64_t float_offset = 0; int64_t uint64_offset = 0; diff --git a/paddle/fluid/framework/data_feed.cu b/paddle/fluid/framework/data_feed.cu index 3c4f2c5bbc..c761e03b84 100644 --- a/paddle/fluid/framework/data_feed.cu +++ b/paddle/fluid/framework/data_feed.cu @@ -219,7 +219,7 @@ int GraphDataGenerator::AcquireInstance(BufState *state) { return 0; } -// TODO opt +// TODO(fengdanlei): opt __global__ void GraphFillFeatureKernel(uint64_t *id_tensor, int *fill_ins_num, uint64_t *walk, @@ -319,7 +319,7 @@ __global__ void GraphFillSlotKernel(uint64_t *id_tensor, CUDA_KERNEL_LOOP(idx, len) { int slot_idx = idx / total_ins; int ins_idx = idx % total_ins; - ((uint64_t *)(id_tensor[slot_idx]))[ins_idx] = + ((uint64_t *)(id_tensor[slot_idx]))[ins_idx] = // NOLINT feature_buf[ins_idx * slot_num + slot_idx]; } } @@ -330,7 +330,7 @@ __global__ void GraphFillSlotLodKernelOpt(uint64_t *id_tensor, CUDA_KERNEL_LOOP(idx, len) { int slot_idx = idx / total_ins; int ins_idx = idx % total_ins; - ((uint64_t *)(id_tensor[slot_idx]))[ins_idx] = ins_idx; + ((uint64_t *)(id_tensor[slot_idx]))[ins_idx] = ins_idx; // NOLINT } } @@ -365,12 +365,12 @@ int GraphDataGenerator::FillInsBuf() { FillFeatureBuf(d_walk_, d_feature_); if (debug_mode_) { int len = buf_size_ > 5000 ? 5000 : buf_size_; - uint64_t h_walk[len]; + uint64_t h_walk[len]; // NOLINT cudaMemcpy(h_walk, d_walk_->ptr(), len * sizeof(uint64_t), cudaMemcpyDeviceToHost); - uint64_t h_feature[len * slot_num_]; + uint64_t h_feature[len * slot_num_]; // NOLINT cudaMemcpy(h_feature, d_feature_->ptr(), len * slot_num_ * sizeof(uint64_t), @@ -431,7 +431,7 @@ int GraphDataGenerator::FillInsBuf() { ins_buf_pair_len_ += h_pair_num; if (debug_mode_) { - uint64_t h_ins_buf[ins_buf_pair_len_ * 2]; + uint64_t h_ins_buf[ins_buf_pair_len_ * 2]; // NOLINT cudaMemcpy(h_ins_buf, ins_buf, 2 * ins_buf_pair_len_ * sizeof(uint64_t), @@ -446,7 +446,7 @@ int GraphDataGenerator::FillInsBuf() { if (!FLAGS_enable_opt_get_features && slot_num_ > 0) { uint64_t *feature_buf = reinterpret_cast(d_feature_buf_->ptr()); - uint64_t h_feature_buf[(batch_size_ * 2 * 2) * slot_num_]; + uint64_t h_feature_buf[(batch_size_ * 2 * 2) * slot_num_]; // NOLINT cudaMemcpy(h_feature_buf, feature_buf, (batch_size_ * 2 * 2) * slot_num_ * sizeof(uint64_t), @@ -574,7 +574,7 @@ int GraphDataGenerator::GenerateBatch() { 0, stream_>>>(clk_tensor_ptr_, total_instance); } else { - ins_cursor = (uint64_t *)id_tensor_ptr_; + ins_cursor = (uint64_t *)id_tensor_ptr_; // NOLINT } if (slot_num_ > 0) { @@ -583,12 +583,12 @@ int GraphDataGenerator::GenerateBatch() { FillFeatureBuf(ins_cursor, feature_buf, total_instance); // FillFeatureBuf(id_tensor_ptr_, feature_buf, total_instance); if (debug_mode_) { - uint64_t h_walk[total_instance]; + uint64_t h_walk[total_instance]; // NOLINT cudaMemcpy(h_walk, ins_cursor, total_instance * sizeof(uint64_t), cudaMemcpyDeviceToHost); - uint64_t h_feature[total_instance * slot_num_]; + uint64_t h_feature[total_instance * slot_num_]; // NOLINT cudaMemcpy(h_feature, feature_buf, total_instance * slot_num_ * sizeof(uint64_t), @@ -608,16 +608,17 @@ int GraphDataGenerator::GenerateBatch() { GraphFillSlotKernel<<>>((uint64_t *)d_slot_tensor_ptr_->ptr(), - feature_buf, - total_instance * slot_num_, - total_instance, - slot_num_); + stream_>>>( + (uint64_t *)d_slot_tensor_ptr_->ptr(), // NOLINT + feature_buf, + total_instance * slot_num_, + total_instance, + slot_num_); GraphFillSlotLodKernelOpt<<>>( - (uint64_t *)d_slot_lod_tensor_ptr_->ptr(), + (uint64_t *)d_slot_lod_tensor_ptr_->ptr(), // NOLINT (total_instance + 1) * slot_num_, total_instance + 1); } else { @@ -828,7 +829,7 @@ void GraphDataGenerator::FillOneStep(uint64_t *d_start_ids, int *h_prefix_sum = new int[len + 1]; int *h_actual_size = new int[len]; int *h_offset2idx = new int[once_max_sample_keynum]; - uint64_t h_sample_keys[once_max_sample_keynum]; + uint64_t h_sample_keys[once_max_sample_keynum]; // NOLINT cudaMemcpy(h_offset2idx, d_tmp_sampleidx2row, once_max_sample_keynum * sizeof(int), @@ -870,11 +871,12 @@ int GraphDataGenerator::FillFeatureBuf( platform::CUDADeviceGuard guard(gpuid_); auto gpu_graph_ptr = GraphGpuWrapper::GetInstance(); - int ret = gpu_graph_ptr->get_feature_of_nodes(gpuid_, - (uint64_t *)d_walk->ptr(), - (uint64_t *)d_feature->ptr(), - buf_size_, - slot_num_); + int ret = gpu_graph_ptr->get_feature_of_nodes( + gpuid_, + (uint64_t *)d_walk->ptr(), // NOLINT + (uint64_t *)d_feature->ptr(), // NOLINT + buf_size_, + slot_num_); return ret; } @@ -1044,8 +1046,9 @@ int GraphDataGenerator::FillWalkBuf(std::shared_ptr d_walk) { return total_row != 0; } -void GraphDataGenerator::AllocResource(const paddle::platform::Place &place, - std::vector feed_vec) { +void GraphDataGenerator::AllocResource( + const paddle::platform::Place &place, + std::vector feed_vec) { place_ = place; gpuid_ = place_.GetDeviceId(); VLOG(3) << "gpuid " << gpuid_; @@ -1195,7 +1198,7 @@ void GraphDataGenerator::SetConfig( meta_path_[i].push_back(iter->second); } } -}; +} } // namespace framework } // namespace paddle diff --git a/paddle/fluid/framework/data_feed.h b/paddle/fluid/framework/data_feed.h index b25093931b..c8142deb99 100644 --- a/paddle/fluid/framework/data_feed.h +++ b/paddle/fluid/framework/data_feed.h @@ -402,7 +402,7 @@ class CustomParser { const char* str, std::vector* instances) { return 0; - }; + } virtual bool ParseOneInstance( const std::string& line, std::function&, int)> @@ -562,8 +562,8 @@ class MiniBatchGpuPack { } } } - LoDTensor& float_tensor(void) { return float_tensor_; } - LoDTensor& uint64_tensor(void) { return uint64_tensor_; } + phi::DenseTensor& float_tensor(void) { return float_tensor_; } + phi::DenseTensor& uint64_tensor(void) { return uint64_tensor_; } HostBuffer& offsets(void) { return offsets_; } HostBuffer& h_tensor_ptrs(void) { return h_tensor_ptrs_; } @@ -628,9 +628,9 @@ class MiniBatchGpuPack { const SlotRecord* batch_ins_ = nullptr; // uint64 tensor - LoDTensor uint64_tensor_; + phi::DenseTensor uint64_tensor_; // float tensor - LoDTensor float_tensor_; + phi::DenseTensor float_tensor_; // batch HostBuffer offsets_; HostBuffer h_tensor_ptrs_; @@ -892,11 +892,11 @@ struct BufState { class GraphDataGenerator { public: - GraphDataGenerator(){}; - virtual ~GraphDataGenerator(){}; + GraphDataGenerator() {} + virtual ~GraphDataGenerator() {} void SetConfig(const paddle::framework::DataFeedDesc& data_feed_desc); void AllocResource(const paddle::platform::Place& place, - std::vector feed_vec); + std::vector feed_vec); int AcquireInstance(BufState* state); int GenerateBatch(); int FillWalkBuf(std::shared_ptr d_walk); @@ -906,7 +906,7 @@ class GraphDataGenerator { void FillOneStep(uint64_t* start_ids, uint64_t* walk, int len, - NeighborSampleResult& sample_res, + NeighborSampleResult& sample_res, // NOLINT int cur_degree, int step, int* len_per_row); @@ -935,7 +935,7 @@ class GraphDataGenerator { int64_t* clk_tensor_ptr_; cudaStream_t stream_; paddle::platform::Place place_; - std::vector feed_vec_; + std::vector feed_vec_; std::vector offset_; std::shared_ptr d_prefix_sum_; std::vector> d_device_keys_; @@ -1106,9 +1106,9 @@ class DataFeed { use_slots_index_; // -1: not used; >=0: the index of use_slots_ // The data read by DataFeed will be stored here - std::vector feed_vec_; + std::vector feed_vec_; - LoDTensor* rank_offset_; + phi::DenseTensor* rank_offset_; // the batch size defined by user int default_batch_size_; @@ -1599,7 +1599,7 @@ class MultiSlotInMemoryDataFeed : public InMemoryDataFeed { virtual bool ParseOneInstanceFromPipe(Record* instance); virtual void ParseOneInstanceFromSo(const char* str, Record* instance, - CustomParser* parser){}; + CustomParser* parser) {} virtual int ParseInstanceFromSo(int len, const char* str, std::vector* instances, diff --git a/paddle/fluid/framework/data_transform.cc b/paddle/fluid/framework/data_transform.cc index db8c3c8c86..8b226fc2c2 100644 --- a/paddle/fluid/framework/data_transform.cc +++ b/paddle/fluid/framework/data_transform.cc @@ -122,9 +122,9 @@ void TransformData(const OpKernelType &expected_kernel_type, void SetTensorToVariable(const Variable &in_var, const phi::DenseTensor &tensor, Variable *out_var) { - if (in_var.IsType()) { - auto &in_lod_tensor = in_var.Get(); - auto *tran_lod_tensor = out_var->GetMutable(); + if (in_var.IsType()) { + auto &in_lod_tensor = in_var.Get(); + auto *tran_lod_tensor = out_var->GetMutable(); tran_lod_tensor->set_lod(in_lod_tensor.lod()); tran_lod_tensor->set_layout(in_lod_tensor.layout()); #ifdef PADDLE_WITH_MKLDNN @@ -139,7 +139,8 @@ void SetTensorToVariable(const Variable &in_var, trans_selected_rows->mutable_value()->ShareDataWith(tensor); } else { PADDLE_THROW(platform::errors::Unavailable( - "Unsupported variable type, only supports LoDTensor or SelectedRows, " + "Unsupported variable type, only supports phi::DenseTensor or " + "SelectedRows, " "but the input variable type is %s.", ToTypeName(in_var.Type()))); } diff --git a/paddle/fluid/framework/details/all_reduce_op_handle.cc b/paddle/fluid/framework/details/all_reduce_op_handle.cc index 1b3ebbb20e..4a7b1d602d 100644 --- a/paddle/fluid/framework/details/all_reduce_op_handle.cc +++ b/paddle/fluid/framework/details/all_reduce_op_handle.cc @@ -131,7 +131,7 @@ void AllReduceOpHandle::AllReduceImpl( var, platform::errors::NotFound("Variable %s is not found in local scope.", in_var_handles[i]->name())); - auto &lod_tensor = var->Get(); + auto &lod_tensor = var->Get(); if (i == 0) { numel = static_cast(lod_tensor.numel()); @@ -246,7 +246,7 @@ void AllReduceOpHandle::AllReduceFunc( } else { // Special handle CPU only Operator's gradient. Like CRF auto &trg = *local_exec_scopes_[0] ->FindVar(out_var_names[0]) - ->GetMutable(); + ->GetMutable(); // Reduce All phi::DenseTensor to trg in CPU ReduceBufferData func(lod_tensor_data, trg.data(), numel); diff --git a/paddle/fluid/framework/details/async_ssa_graph_executor.cc b/paddle/fluid/framework/details/async_ssa_graph_executor.cc index 9e22033d86..e17ea867bf 100644 --- a/paddle/fluid/framework/details/async_ssa_graph_executor.cc +++ b/paddle/fluid/framework/details/async_ssa_graph_executor.cc @@ -177,9 +177,10 @@ FetchResultType AsyncSSAGraphExecutor::Run( auto &val = PADDLE_GET(FetchList, fetch_data); for (size_t fetch_idx = 0; fetch_idx < fetch_tensors.size(); ++fetch_idx) { if (data_is_lod_tensor(val.at(fetch_idx))) { - std::vector lodtensor_ptrs; - lodtensor_ptrs.push_back(&(PADDLE_GET(LoDTensor, val.at(fetch_idx)))); - LoDTensor var; + std::vector lodtensor_ptrs; + lodtensor_ptrs.push_back( + &(PADDLE_GET(phi::DenseTensor, val.at(fetch_idx)))); + phi::DenseTensor var; MergeLoDTensor(&var, lodtensor_ptrs, platform::CPUPlace()); ret.emplace_back(var); } else { @@ -187,7 +188,7 @@ FetchResultType AsyncSSAGraphExecutor::Run( LoDTensorArray item_array; item_array.reserve(array.size()); for (size_t i = 0; i < array.size(); ++i) { - std::vector lodtensor_ptrs; + std::vector lodtensor_ptrs; lodtensor_ptrs.push_back(&array[i]); item_array.emplace_back(); MergeLoDTensor( diff --git a/paddle/fluid/framework/details/eager_deletion_op_handle.cc b/paddle/fluid/framework/details/eager_deletion_op_handle.cc index 1e384143a3..ade3a6f842 100644 --- a/paddle/fluid/framework/details/eager_deletion_op_handle.cc +++ b/paddle/fluid/framework/details/eager_deletion_op_handle.cc @@ -150,8 +150,9 @@ void EagerDeletionOpHandle::RunImpl() { Variable *var = vars_[i]; - if (var->IsType()) { - garbages.emplace_back(var->GetMutable()->MoveMemoryHolder()); + if (var->IsType()) { + garbages.emplace_back( + var->GetMutable()->MoveMemoryHolder()); } else if (var->IsType()) { garbages.emplace_back(var->GetMutable() ->mutable_value() diff --git a/paddle/fluid/framework/details/fetch_async_op_handle.cc b/paddle/fluid/framework/details/fetch_async_op_handle.cc index b84a94718c..922dbb4880 100644 --- a/paddle/fluid/framework/details/fetch_async_op_handle.cc +++ b/paddle/fluid/framework/details/fetch_async_op_handle.cc @@ -45,7 +45,7 @@ void FetchAsyncOpHandle::RecordWaitEventOnCtx( "No nodes need to wait FetchAsyncOp. Unexpceted Error.")); } -static void CheckTensorAttrs(const LoDTensor *tensor, +static void CheckTensorAttrs(const phi::DenseTensor *tensor, const proto::VarType::Type &type, const DataLayout &layout, const DDim &dims, @@ -145,8 +145,8 @@ static void TransData(const phi::DenseTensor *src_item, } void FetchAsyncOpHandle::FetchMergedLodTensor( - const std::vector &src_lodtensors, - LoDTensor *dst_lodtensor) { + const std::vector &src_lodtensors, + phi::DenseTensor *dst_lodtensor) { // calc dst type,layout,dim,lod and calc check dim proto::VarType::Type new_type = proto::VarType::FP32; phi::DataLayout new_layout; @@ -245,15 +245,15 @@ void FetchAsyncOpHandle::RunImpl() { if (return_merged_) { auto &val = PADDLE_GET(FetchList, *data_); - if (src_vars[0]->IsType()) { + if (src_vars[0]->IsType()) { // to lodtensor type - std::vector src_lodtensors; + std::vector src_lodtensors; src_lodtensors.reserve(src_vars.size()); for (size_t i = 0; i < src_vars.size(); ++i) { src_lodtensors.emplace_back(&src_vars[i]->Get()); } - LoDTensor dst_lodtensor; + phi::DenseTensor dst_lodtensor; FetchMergedLodTensor(src_lodtensors, &dst_lodtensor); val.at(offset_) = std::move(dst_lodtensor); } else { @@ -269,7 +269,7 @@ void FetchAsyncOpHandle::RunImpl() { dst_lodtensor_array.resize(src_lodtensor_arrays[0]->size()); for (size_t i = 0; i < dst_lodtensor_array.size(); ++i) { - std::vector src_lodtensors; + std::vector src_lodtensors; src_lodtensors.reserve(src_lodtensor_arrays.size()); for (size_t j = 0; j < src_lodtensor_arrays.size(); ++j) { src_lodtensors.emplace_back(&(*src_lodtensor_arrays[j])[i]); @@ -284,9 +284,9 @@ void FetchAsyncOpHandle::RunImpl() { dst_tensors.reserve(src_vars.size()); for (size_t i = 0; i < src_vars.size(); ++i) { - if (src_vars[i]->IsType()) { + if (src_vars[i]->IsType()) { auto &t = src_vars[i]->Get(); - LoDTensor item; + phi::DenseTensor item; TransData(&t, &item, *dev_ctxes_[t.place()]); dst_tensors.emplace_back(std::move(item)); } else { diff --git a/paddle/fluid/framework/details/fetch_async_op_handle.h b/paddle/fluid/framework/details/fetch_async_op_handle.h index 86432bb09e..f22d2b03b5 100644 --- a/paddle/fluid/framework/details/fetch_async_op_handle.h +++ b/paddle/fluid/framework/details/fetch_async_op_handle.h @@ -62,8 +62,8 @@ struct FetchAsyncOpHandle : public OpHandleBase { std::vector GetLocalScopes() override { return *local_scopes_; } void FetchMergedLodTensor( - const std::vector &src_lodtensors, - LoDTensor *dst_lodtensor); + const std::vector &src_lodtensors, + phi::DenseTensor *dst_lodtensor); private: FetchResultType *data_; diff --git a/paddle/fluid/framework/details/fetch_op_handle.cc b/paddle/fluid/framework/details/fetch_op_handle.cc index 6b6317e352..a36b63da9b 100644 --- a/paddle/fluid/framework/details/fetch_op_handle.cc +++ b/paddle/fluid/framework/details/fetch_op_handle.cc @@ -74,18 +74,20 @@ static void CheckDims(const framework::DDim &tensor_dims, void FetchOpHandle::WaitAndMergeCPUFetchVars() const { if (return_merged_) { if (data_is_lod_tensor(tensors_[0])) { - const auto &tensor_dims = PADDLE_GET_CONST(LoDTensor, tensors_[0]).dims(); + const auto &tensor_dims = + PADDLE_GET_CONST(phi::DenseTensor, tensors_[0]).dims(); for (size_t i = 1; i < tensors_.size(); i++) { - const auto &ele_dims = PADDLE_GET_CONST(LoDTensor, tensors_[i]).dims(); + const auto &ele_dims = + PADDLE_GET_CONST(phi::DenseTensor, tensors_[i]).dims(); CheckDims(tensor_dims, ele_dims, offset_); } - std::vector tensors_ptr; + std::vector tensors_ptr; tensors_ptr.reserve(tensors_.size()); for (auto &t : tensors_) { - tensors_ptr.emplace_back(&PADDLE_GET_CONST(LoDTensor, t)); + tensors_ptr.emplace_back(&PADDLE_GET_CONST(phi::DenseTensor, t)); } auto &val = PADDLE_GET(FetchList, *data_); - LoDTensor var; + phi::DenseTensor var; MergeLoDTensor(&var, tensors_ptr, platform::CPUPlace()); val.at(offset_) = std::move(var); } else { @@ -94,7 +96,7 @@ void FetchOpHandle::WaitAndMergeCPUFetchVars() const { tmp_array.reserve(array.size()); for (size_t i = 0; i < array.size(); ++i) { const auto &tensor_dims = array[i].dims(); - std::vector tensors_ptr; + std::vector tensors_ptr; tensors_ptr.reserve(tensors_.size()); tensors_ptr.push_back(&array[i]); for (size_t j = 1; j < tensors_.size(); ++j) { @@ -149,9 +151,9 @@ void FetchOpHandle::RunImpl() { platform::errors::NotFound( "Cannot find variable %s in execution scope.", var_handle->name())); - if (var->IsType()) { + if (var->IsType()) { auto &t = var->Get(); - auto &item = PADDLE_GET(LoDTensor, tensors_[i]); + auto &item = PADDLE_GET(phi::DenseTensor, tensors_[i]); TransData(t, &item); } else { auto &t = var->Get(); diff --git a/paddle/fluid/framework/details/fused_all_reduce_op_handle.cc b/paddle/fluid/framework/details/fused_all_reduce_op_handle.cc index 990de22aa0..bca280fc35 100644 --- a/paddle/fluid/framework/details/fused_all_reduce_op_handle.cc +++ b/paddle/fluid/framework/details/fused_all_reduce_op_handle.cc @@ -27,7 +27,8 @@ namespace paddle { namespace framework { namespace details { -typedef std::vector>> +typedef std::vector< + std::vector>> GradientAndLoDTensor; #if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL) @@ -238,10 +239,9 @@ void FusedAllReduceOpHandle::FusedAllReduceFunc( std::sort( g_tensor.begin(), g_tensor.end(), - [](const std::pair &grad1, - const std::pair &grad2) -> bool { - return grad1.second->data() < grad2.second->data(); - }); + [](const std::pair &grad1, + const std::pair &grad2) + -> bool { return grad1.second->data() < grad2.second->data(); }); size_t size_of_dtype = framework::SizeOfType(dtype); for (size_t k = 1; k < g_tensor.size(); ++k) { @@ -320,7 +320,7 @@ bool FusedAllReduceOpHandle::InputIsInDifferentPlace( var, platform::errors::NotFound( "The variable '%s' is not found in local scope.", var_name)); - auto &lod_tensor = var->Get(); + auto &lod_tensor = var->Get(); if (!platform::is_same_place(lod_tensor.place(), places_.at(scope_idx))) { return true; } @@ -333,7 +333,8 @@ void FusedAllReduceOpHandle::GetGradLoDTensor( const size_t &scope_idx, const std::vector &in_var_handles, const std::vector &out_var_handles, - std::vector> *grad_tensor) const { + std::vector> *grad_tensor) + const { auto *local_scope = local_exec_scopes_[scope_idx]; size_t place_num = places_.size(); for (size_t j = 0; j < in_var_handles.size(); j += place_num) { @@ -352,7 +353,7 @@ void FusedAllReduceOpHandle::GetGradLoDTensor( var, platform::errors::NotFound( "The variable '%s' is not found in local scope.", var_name)); - auto &lod_tensor = var->Get(); + auto &lod_tensor = var->Get(); PADDLE_ENFORCE_EQ( platform::is_same_place(lod_tensor.place(), places_.at(scope_idx)), @@ -366,7 +367,8 @@ void FusedAllReduceOpHandle::GetGradLoDTensor( } void FusedAllReduceOpHandle::GetDTypeAndNumel( - const std::vector> &grad_tensor, + const std::vector> + &grad_tensor, proto::VarType::Type *dtype, int64_t *numel) const { *numel = 0; diff --git a/paddle/fluid/framework/details/fused_all_reduce_op_handle.h b/paddle/fluid/framework/details/fused_all_reduce_op_handle.h index 267329851d..533d1d0860 100644 --- a/paddle/fluid/framework/details/fused_all_reduce_op_handle.h +++ b/paddle/fluid/framework/details/fused_all_reduce_op_handle.h @@ -82,16 +82,18 @@ struct FusedAllReduceOpHandle : public AllReduceOpHandle { // Check the dtype of the input void GetDTypeAndNumel( - const std::vector> &g_tensor, + const std::vector> + &g_tensor, proto::VarType::Type *dtype, int64_t *total_num) const; - // Get gradient's name and LoDTensor - void GetGradLoDTensor(const size_t &scope_idx, - const std::vector &in_var_handles, - const std::vector &out_var_handles, - std::vector> - *grad_tensor) const; + // Get gradient's name and phi::DenseTensor + void GetGradLoDTensor( + const size_t &scope_idx, + const std::vector &in_var_handles, + const std::vector &out_var_handles, + std::vector> + *grad_tensor) const; bool InputIsInDifferentPlace( const std::vector &in_var_handles) const; diff --git a/paddle/fluid/framework/details/grad_merge_all_reduce_op_handle.cc b/paddle/fluid/framework/details/grad_merge_all_reduce_op_handle.cc index d7e846b02e..0f79d781d1 100644 --- a/paddle/fluid/framework/details/grad_merge_all_reduce_op_handle.cc +++ b/paddle/fluid/framework/details/grad_merge_all_reduce_op_handle.cc @@ -65,7 +65,7 @@ void GradMergeAllReduceOpHandle::RunImpl() { PADDLE_ENFORCE_NOT_NULL(cond_var, platform::errors::NotFound( "Variable %s is not found in scope.", cond_var)); - bool cond = *cond_var->Get().data(); + bool cond = *cond_var->Get().data(); if (cond) { AllReduceOpHandle::RunImpl(); @@ -123,7 +123,7 @@ void FusedGradMergeAllReduceOpHandle::RunImpl() { PADDLE_ENFORCE_NOT_NULL(cond_var, platform::errors::NotFound( "Variable %s is not found in scope.", cond_var)); - bool cond = *cond_var->Get().data(); + bool cond = *cond_var->Get().data(); if (cond) { VLOG(10) << "run fused grad merge all reduce"; diff --git a/paddle/fluid/framework/details/parallel_ssa_graph_executor.cc b/paddle/fluid/framework/details/parallel_ssa_graph_executor.cc index 3918c718e9..a2dd00c008 100644 --- a/paddle/fluid/framework/details/parallel_ssa_graph_executor.cc +++ b/paddle/fluid/framework/details/parallel_ssa_graph_executor.cc @@ -270,7 +270,7 @@ FetchResultType ParallelSSAGraphExecutor::Run( FetchList ret; ret.reserve(fetch_tensors.size()); for (size_t fetch_idx = 0; fetch_idx < fetch_tensors.size(); ++fetch_idx) { - std::vector lodtensor_ptrs; + std::vector lodtensor_ptrs; lodtensor_ptrs.reserve(place_num); std::vector lodtensorarray_ptrs; lodtensorarray_ptrs.reserve(place_num); @@ -282,21 +282,21 @@ FetchResultType ParallelSSAGraphExecutor::Run( PADDLE_GET_CONST(FetchList, fetch_data[scope_idx]); if (data_is_lod_tensor(fetch_list[fetch_idx])) { lodtensor_ptrs.push_back( - &(PADDLE_GET_CONST(LoDTensor, fetch_list[fetch_idx]))); + &(PADDLE_GET_CONST(phi::DenseTensor, fetch_list[fetch_idx]))); } else { lodtensorarray_ptrs.push_back( &(PADDLE_GET_CONST(LoDTensorArray, fetch_list[fetch_idx]))); } } if (lodtensor_ptrs.size() != 0) { - LoDTensor var; + phi::DenseTensor var; MergeLoDTensor(&var, lodtensor_ptrs, platform::CPUPlace()); ret.emplace_back(var); } else { LoDTensorArray var_array(lodtensorarray_ptrs[0]->size()); for (size_t i = 0; i < lodtensorarray_ptrs[0]->size(); ++i) { - LoDTensor var; - std::vector ptrs; + phi::DenseTensor var; + std::vector ptrs; for (size_t j = 0; j < lodtensorarray_ptrs.size(); ++j) { ptrs.push_back(&(lodtensorarray_ptrs[j]->at(i))); } @@ -323,7 +323,7 @@ FetchResultType ParallelSSAGraphExecutor::Run( fetch_list[fetch_idx].size(), 1, platform::errors::Fatal("Each place must have only one fetched " - "LoDTensor/LoDTensorArray!")); + "phi::DenseTensor/LoDTensorArray!")); ret.back().emplace_back(fetch_list[fetch_idx][0]); } } diff --git a/paddle/fluid/framework/details/reduce_and_gather.h b/paddle/fluid/framework/details/reduce_and_gather.h index a1715062d4..b2f87d94d8 100644 --- a/paddle/fluid/framework/details/reduce_and_gather.h +++ b/paddle/fluid/framework/details/reduce_and_gather.h @@ -30,10 +30,11 @@ namespace framework { namespace details { struct ReduceLoDTensor { - const std::vector &src_tensors_; - LoDTensor &dst_tensor_; + const std::vector &src_tensors_; + phi::DenseTensor &dst_tensor_; - ReduceLoDTensor(const std::vector &src, LoDTensor *dst) + ReduceLoDTensor(const std::vector &src, + phi::DenseTensor *dst) : src_tensors_(src), dst_tensor_(*dst) {} template diff --git a/paddle/fluid/framework/details/reduce_op_handle.cc b/paddle/fluid/framework/details/reduce_op_handle.cc index 3d817fd2da..a81269b1ec 100644 --- a/paddle/fluid/framework/details/reduce_op_handle.cc +++ b/paddle/fluid/framework/details/reduce_op_handle.cc @@ -150,8 +150,8 @@ void ReduceOpHandle::RunImpl() { } }); } else { - std::vector lod_tensors = - GetInputValues(in_var_handles, var_scopes); + std::vector lod_tensors = + GetInputValues(in_var_handles, var_scopes); if (paddle::platform::is_cpu_place(lod_tensors[0]->place())) { WaitInputVarGenerated(); diff --git a/paddle/fluid/framework/details/scale_loss_grad_op_handle.cc b/paddle/fluid/framework/details/scale_loss_grad_op_handle.cc index 9c9d670a27..9dac1a7203 100644 --- a/paddle/fluid/framework/details/scale_loss_grad_op_handle.cc +++ b/paddle/fluid/framework/details/scale_loss_grad_op_handle.cc @@ -107,7 +107,7 @@ void ScaleLossGradOpHandle::RunImpl() { } void ScaleLossGradOpHandle::RunOnVar(Variable *var, bool record_event) { - auto *tensor = var->GetMutable(); + auto *tensor = var->GetMutable(); tensor->Resize(phi::make_ddim({1})); #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) diff --git a/paddle/fluid/framework/details/scope_buffered_monitor.cc b/paddle/fluid/framework/details/scope_buffered_monitor.cc index 7f9f7a5373..88a074763e 100644 --- a/paddle/fluid/framework/details/scope_buffered_monitor.cc +++ b/paddle/fluid/framework/details/scope_buffered_monitor.cc @@ -32,8 +32,9 @@ static constexpr double kMB = 1 / (1024 * 1024); static void GetTensors(Variable *var, std::unordered_set *tensor_set) { - if (var->IsType() && var->Get().IsInitialized()) { - tensor_set->insert(var->GetMutable()); + if (var->IsType() && + var->Get().IsInitialized()) { + tensor_set->insert(var->GetMutable()); } else if (var->IsType() && var->Get().value().IsInitialized()) { tensor_set->insert(var->GetMutable()->mutable_value()); diff --git a/paddle/fluid/framework/details/scope_buffered_ssa_graph_executor.cc b/paddle/fluid/framework/details/scope_buffered_ssa_graph_executor.cc index 80d801916a..8e1a967020 100644 --- a/paddle/fluid/framework/details/scope_buffered_ssa_graph_executor.cc +++ b/paddle/fluid/framework/details/scope_buffered_ssa_graph_executor.cc @@ -133,7 +133,7 @@ FetchResultType ScopeBufferedSSAGraphExecutor::Run( bool ScopeBufferedSSAGraphExecutor::DropScopeOrNot() const { for (auto &var : tensor_array_vars_) { auto tensor_array = var->GetMutable(); - for (LoDTensor &tensor : *tensor_array) { + for (phi::DenseTensor &tensor : *tensor_array) { if (tensor.IsInitialized()) { return true; } diff --git a/paddle/fluid/framework/details/share_tensor_buffer_functor.h b/paddle/fluid/framework/details/share_tensor_buffer_functor.h index d92bc0f0b0..4c1e4732e1 100644 --- a/paddle/fluid/framework/details/share_tensor_buffer_functor.h +++ b/paddle/fluid/framework/details/share_tensor_buffer_functor.h @@ -41,21 +41,21 @@ namespace details { // TODO(zjl): support SelectedRows static inline const phi::DenseTensor &GetTensorFromVar(const Variable *var) { - if (var->IsType()) { - return var->Get(); + if (var->IsType()) { + return var->Get(); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Variable must be type of LoDTensor, but received %s.", + "Variable must be type of phi::DenseTensor, but received %s.", framework::ToTypeName(var->Type()))); } } static inline phi::DenseTensor *GetMutableTensorFromVar(Variable *var) { - if (var->IsType()) { - return var->GetMutable(); + if (var->IsType()) { + return var->GetMutable(); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Variable must be type of LoDTensor, but received %s.", + "Variable must be type of phi::DenseTensor, but received %s.", framework::ToTypeName(var->Type()))); } } diff --git a/paddle/fluid/framework/details/sparse_all_reduce_op_handle.cc b/paddle/fluid/framework/details/sparse_all_reduce_op_handle.cc index c0dd85cb50..d4397225ac 100644 --- a/paddle/fluid/framework/details/sparse_all_reduce_op_handle.cc +++ b/paddle/fluid/framework/details/sparse_all_reduce_op_handle.cc @@ -66,7 +66,8 @@ SparseAllReduceOpHandle::SparseAllReduceOpHandle( platform::errors::NotFound("Variable %s is not found in scope.", nranks_name)); - float *dgc_nranks = nranks_var->GetMutable()->data(); + float *dgc_nranks = + nranks_var->GetMutable()->data(); *dgc_nranks = nranks; VLOG(10) << "dgc_nranks=" << *dgc_nranks; } @@ -97,9 +98,9 @@ void SparseAllReduceOpHandle::RunImplEncoded() { in_var_handles.size(), out_var_handles.size())); - std::vector ins; - std::vector gathers; - std::vector outs; + std::vector ins; + std::vector gathers; + std::vector outs; int k = -1; for (size_t i = 0; i < local_scopes_.size(); ++i) { auto *local_scope = local_exec_scopes_[i]; @@ -112,7 +113,7 @@ void SparseAllReduceOpHandle::RunImplEncoded() { in_var, platform::errors::NotFound("Variable %s is not found in scope.", encode_var_name)); - auto &in = in_var->Get(); + auto &in = in_var->Get(); ins.emplace_back(&in); auto gather_var_name = original_name + g_dgc_gather; @@ -121,11 +122,11 @@ void SparseAllReduceOpHandle::RunImplEncoded() { gather_var, platform::errors::NotFound("Variable %s is not found in scope.", gather_var)); - auto *gather = gather_var->GetMutable(); + auto *gather = gather_var->GetMutable(); gathers.emplace_back(gather); auto *out = local_scope->FindVar(out_var_handles[i]->name()) - ->GetMutable(); + ->GetMutable(); outs.emplace_back(out); if (k < 0) { @@ -268,7 +269,7 @@ int SparseAllReduceOpHandle::GetKValue(const std::string &grad_name) { PADDLE_ENFORCE_NOT_NULL(var, platform::errors::NotFound( "Variable %s is not found in scope.", var_name)); - auto tensor = var->Get().data(); + auto tensor = var->Get().data(); return *tensor; } @@ -297,8 +298,8 @@ bool SparseAllReduceOpHandle::IsEncoded() { platform::errors::NotFound( "Variable %s is not found in scope.", step_var)); - float count = *count_var->Get().data(); - float step = *step_var->Get().data(); + float count = *count_var->Get().data(); + float step = *step_var->Get().data(); if (static_cast(count) < static_cast(step)) { VLOG(10) << "in all_reduce currentstep:" << count << " < rampup_begin_step:" << step diff --git a/paddle/fluid/framework/details/variable_visitor.cc b/paddle/fluid/framework/details/variable_visitor.cc index a495e40501..06587a5772 100644 --- a/paddle/fluid/framework/details/variable_visitor.cc +++ b/paddle/fluid/framework/details/variable_visitor.cc @@ -32,8 +32,8 @@ namespace framework { namespace details { template static void VisitVariable(Variable* var, Func* func) { - if (var->IsType()) { - (*func)(var->GetMutable()); + if (var->IsType()) { + (*func)(var->GetMutable()); } else if (var->IsType()) { (*func)(var->GetMutable()); } else { @@ -45,8 +45,8 @@ static void VisitVariable(Variable* var, Func* func) { template static void VisitVariable(const Variable& var, Func* func) { - if (var.IsType()) { - (*func)(var.Get()); + if (var.IsType()) { + (*func)(var.Get()); } else if (var.IsType()) { (*func)(var.Get()); } else { @@ -58,7 +58,7 @@ static void VisitVariable(const Variable& var, Func* func) { struct TensorVisitor { phi::DenseTensor* result_{nullptr}; - void operator()(LoDTensor* tensor) { result_ = tensor; } + void operator()(phi::DenseTensor* tensor) { result_ = tensor; } void operator()(phi::SelectedRows* selected_rows) { result_ = selected_rows->mutable_value(); @@ -79,8 +79,8 @@ phi::DenseTensor& VariableVisitor::GetMutableTensor(Variable* var) { struct ShareDimsAndLoDVisitor { Variable* trg_; - void operator()(const LoDTensor& val) { - auto* tensor = trg_->GetMutable(); + void operator()(const phi::DenseTensor& val) { + auto* tensor = trg_->GetMutable(); tensor->set_layout(val.layout()); tensor->set_lod(val.lod()); tensor->Resize(val.dims()); @@ -108,8 +108,8 @@ void VariableVisitor::ShareDimsAndLoD(const Variable& src, Variable* trg) { struct EnforceShapeAndDTypeEQVisitor { const Variable* dst_; - void operator()(const LoDTensor& src) { - auto& tensor = dst_->Get(); + void operator()(const phi::DenseTensor& src) { + auto& tensor = dst_->Get(); PADDLE_ENFORCE_EQ( src.place().GetType(), tensor.place().GetType(), diff --git a/paddle/fluid/framework/device_worker.cc b/paddle/fluid/framework/device_worker.cc index 21da0d7c4d..11869ec575 100644 --- a/paddle/fluid/framework/device_worker.cc +++ b/paddle/fluid/framework/device_worker.cc @@ -205,7 +205,8 @@ void PrintLodTensor(phi::DenseTensor* tensor, } } -std::pair GetTensorBound(LoDTensor* tensor, int index) { +std::pair GetTensorBound(phi::DenseTensor* tensor, + int index) { auto& dims = tensor->dims(); if (tensor->lod().size() != 0) { auto& lod = tensor->lod()[0]; @@ -215,7 +216,7 @@ std::pair GetTensorBound(LoDTensor* tensor, int index) { } } -bool CheckValidOutput(LoDTensor* tensor, size_t batch_size) { +bool CheckValidOutput(phi::DenseTensor* tensor, size_t batch_size) { auto& dims = tensor->dims(); if (dims.size() != 2) return false; if (tensor->lod().size() != 0) { @@ -239,7 +240,7 @@ void DeviceWorker::DumpParam(const Scope& scope, const int batch_id) { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); phi::DenseTensor cpu_tensor; if (platform::is_gpu_place(tensor->place())) { TensorCopySync(*tensor, platform::CPUPlace(), &cpu_tensor); @@ -292,7 +293,7 @@ void DeviceWorker::DumpField(const Scope& scope, << "] cannot be find in scope, so it was skipped."; continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (!tensor->IsInitialized()) { VLOG(0) << "Note: field[" << field << "] is not initialized, so it was skipped."; @@ -315,8 +316,9 @@ void DeviceWorker::DumpField(const Scope& scope, if (dump_fields_ == NULL || (*dump_fields_).size() == 0) { return; } - auto set_output_str = [&, this]( - size_t begin, size_t end, LoDTensor* tensor) { + auto set_output_str = [&, this](size_t begin, + size_t end, + phi::DenseTensor* tensor) { std::pair bound; auto& dims = tensor->dims(); for (size_t i = begin; i < end; ++i) { @@ -339,7 +341,7 @@ void DeviceWorker::DumpField(const Scope& scope, << "] cannot be find in scope, so it was skipped."; continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (!tensor->IsInitialized()) { VLOG(0) << "Note: field[" << field << "] is not initialized, so it was skipped."; @@ -422,7 +424,7 @@ void DeviceWorker::DumpField(const Scope& scope, << "] cannot be find in scope, so it was skipped."; continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (!tensor->IsInitialized()) { VLOG(0) << "Note: field[" << field << "] is not initialized, so it was skipped."; diff --git a/paddle/fluid/framework/device_worker.h b/paddle/fluid/framework/device_worker.h index 6276d0c500..fa54a723ad 100644 --- a/paddle/fluid/framework/device_worker.h +++ b/paddle/fluid/framework/device_worker.h @@ -70,8 +70,8 @@ void PrintLodTensor(phi::DenseTensor* tensor, std::string& output_str, // NOLINT char separator = ',', bool need_leading_separator = false); -std::pair GetTensorBound(LoDTensor* tensor, int index); -bool CheckValidOutput(LoDTensor* tensor, size_t batch_size); +std::pair GetTensorBound(phi::DenseTensor* tensor, int index); +bool CheckValidOutput(phi::DenseTensor* tensor, size_t batch_size); class FleetWrapper; @@ -274,7 +274,9 @@ class HogwildWorker : public CPUWorkerBase { virtual void CreateDeviceResource(const ProgramDesc& main_prog); virtual void BindingDataFeedMemory(); template - void SetZero(LoDTensor* tensor, LoDTensor* root_tensor, int tensor_dim); + void SetZero(phi::DenseTensor* tensor, + phi::DenseTensor* root_tensor, + int tensor_dim); protected: void CreateThreadOperators(const ProgramDesc& program); diff --git a/paddle/fluid/framework/device_worker_test.cc b/paddle/fluid/framework/device_worker_test.cc index a31df078b3..3008e8b86c 100644 --- a/paddle/fluid/framework/device_worker_test.cc +++ b/paddle/fluid/framework/device_worker_test.cc @@ -21,7 +21,7 @@ namespace paddle { namespace framework { TEST(LodTensor, PrintLodTensor) { - LoDTensor tensor1; + phi::DenseTensor tensor1; tensor1.Resize({2}); tensor1.mutable_data(platform::CPUPlace()); tensor1.data()[0] = 0.2; @@ -31,7 +31,7 @@ TEST(LodTensor, PrintLodTensor) { res = PrintLodTensor(&tensor1, 0, 2); ASSERT_EQ(res, "0.2,0.5"); - LoDTensor tensor2; + phi::DenseTensor tensor2; tensor2.Resize({2}); tensor2.mutable_data(platform::CPUPlace()); tensor2.data()[0] = 1; @@ -41,7 +41,7 @@ TEST(LodTensor, PrintLodTensor) { res = PrintLodTensor(&tensor2, 0, 2); ASSERT_EQ(res, "1,2"); - LoDTensor tensor3; + phi::DenseTensor tensor3; tensor3.Resize({2}); tensor3.mutable_data(platform::CPUPlace()); tensor3.data()[0] = 0.1; @@ -49,7 +49,7 @@ TEST(LodTensor, PrintLodTensor) { res = PrintLodTensor(&tensor3, 0, 2); ASSERT_EQ(res, "0.1,0.2"); - LoDTensor tensor4; + phi::DenseTensor tensor4; tensor4.Resize({2}); tensor4.mutable_data(platform::CPUPlace()); tensor4.data()[0] = 0.1; @@ -58,7 +58,7 @@ TEST(LodTensor, PrintLodTensor) { PrintLodTensor(&tensor4, 0, 2, res); // ASSERT_EQ(res, "0.1,0.2"); - LoDTensor tensor5; + phi::DenseTensor tensor5; tensor5.Resize({2}); tensor5.mutable_data(platform::CPUPlace()); tensor5.data()[0] = 1; @@ -70,7 +70,7 @@ TEST(LodTensor, PrintLodTensor) { PrintLodTensor(&tensor5, 0, 2, res); ASSERT_EQ(res, "1,2"); - LoDTensor tensor6; + phi::DenseTensor tensor6; tensor6.Resize({2}); tensor6.mutable_data(platform::CPUPlace()); tensor6.data()[0] = 0.2; @@ -85,7 +85,7 @@ TEST(LodTensor, PrintLodTensor) { TEST(LodTensor, GetTensorBound) { LoD lod{{0, 2}}; - LoDTensor tensor; + phi::DenseTensor tensor; tensor.set_lod(lod); tensor.Resize({2, 1}); tensor.mutable_data(platform::CPUPlace()); @@ -98,7 +98,7 @@ TEST(LodTensor, GetTensorBound) { TEST(LodTensor, CheckValidOutput) { LoD lod{{0, 1, 2}}; - LoDTensor tensor; + phi::DenseTensor tensor; tensor.set_lod(lod); tensor.Resize({2, 1}); tensor.mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/dist_multi_trainer.cc b/paddle/fluid/framework/dist_multi_trainer.cc index 7f9aac4d3f..5b93b4bcef 100644 --- a/paddle/fluid/framework/dist_multi_trainer.cc +++ b/paddle/fluid/framework/dist_multi_trainer.cc @@ -154,12 +154,13 @@ void DistMultiTrainer::Finalize() { if (root_var == nullptr) { continue; } - LoDTensor *root_tensor = root_var->GetMutable(); + phi::DenseTensor *root_tensor = root_var->GetMutable(); for (int j = 1; j < thread_num_; j++) { Scope *cur_thread_scope = workers_[j]->GetThreadScope(); Variable *thread_var = cur_thread_scope->FindVar(need_merge_var_names_[i]); - LoDTensor *thread_tensor = thread_var->GetMutable(); + phi::DenseTensor *thread_tensor = + thread_var->GetMutable(); if (root_tensor->numel() != thread_tensor->numel()) { continue; } @@ -197,8 +198,8 @@ void DistMultiTrainer::Finalize() { } template -void DistMultiTrainer::MergeToRootScope(LoDTensor *root_tensor, - LoDTensor *tensor) { +void DistMultiTrainer::MergeToRootScope(phi::DenseTensor *root_tensor, + phi::DenseTensor *tensor) { T *root_data = root_tensor->data(); T *data = tensor->data(); for (int i = 0; i < tensor->numel(); i++) { diff --git a/paddle/fluid/framework/downpour_lite_worker.cc b/paddle/fluid/framework/downpour_lite_worker.cc index ed59d6247f..4c60d6b5b9 100644 --- a/paddle/fluid/framework/downpour_lite_worker.cc +++ b/paddle/fluid/framework/downpour_lite_worker.cc @@ -204,14 +204,14 @@ void DownpourLiteWorker::CopyDenseVars() { << dest_var_name; Variable* src_var = thread_scope_->FindVar(src_var_name); CHECK(src_var != nullptr) << src_var_name << " not found"; // NOLINT - LoDTensor* src_tensor = src_var->GetMutable(); + phi::DenseTensor* src_tensor = src_var->GetMutable(); CHECK(src_tensor != nullptr) << src_var_name << " tensor is null"; // NOLINT float* src_data = src_tensor->data(); Variable* dest_var = thread_scope_->FindVar(dest_var_name); CHECK(dest_var != nullptr) << dest_var_name << " not found"; // NOLINT - LoDTensor* dest_tensor = dest_var->GetMutable(); + phi::DenseTensor* dest_tensor = dest_var->GetMutable(); CHECK(dest_tensor != nullptr) << dest_var_name << " tensor is null"; // NOLINT float* dest_data = dest_tensor->data(); @@ -307,7 +307,7 @@ void DownpourLiteWorker::TrainFilesWithProfiler() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } @@ -490,7 +490,7 @@ void DownpourLiteWorker::TrainFiles() { phi::DenseTensor* tensor = nullptr; int64_t len = 0; if (var->IsType()) { - tensor = var->GetMutable(); + tensor = var->GetMutable(); len = tensor->numel(); } else if (var->IsType()) { auto selected_rows = var->GetMutable(); @@ -527,7 +527,7 @@ void DownpourLiteWorker::TrainFiles() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } diff --git a/paddle/fluid/framework/downpour_worker.cc b/paddle/fluid/framework/downpour_worker.cc index eaba13f7b0..01f6abb59d 100644 --- a/paddle/fluid/framework/downpour_worker.cc +++ b/paddle/fluid/framework/downpour_worker.cc @@ -144,7 +144,7 @@ void DownpourWorker::CollectLabelInfo(size_t table_idx) { auto& feature_label = feature_labels_[table_id]; feature_label.resize(feature.size()); Variable* var = thread_scope_->FindVar(label_var_name_[table_id]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* label_ptr = tensor->data(); size_t global_index = 0; @@ -155,7 +155,7 @@ void DownpourWorker::CollectLabelInfo(size_t table_idx) { if (fea_var == nullptr) { continue; } - LoDTensor* tensor = fea_var->GetMutable(); + phi::DenseTensor* tensor = fea_var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << sparse_key_names_[table_id][i] << " is null"; @@ -207,7 +207,7 @@ void DownpourWorker::FillSparseValue(size_t table_idx) { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << slot_name << " is null"; int64_t* ids = tensor->data(); int len = tensor->numel(); @@ -215,7 +215,7 @@ void DownpourWorker::FillSparseValue(size_t table_idx) { if (var_emb == nullptr) { continue; } - LoDTensor* tensor_emb = var_emb->GetMutable(); + phi::DenseTensor* tensor_emb = var_emb->GetMutable(); float* ptr = tensor_emb->mutable_data({len, table.emb_dim()}, platform::CPUPlace()); memset(ptr, 0, sizeof(float) * len * table.emb_dim()); @@ -290,7 +290,7 @@ void DownpourWorker::AdjustInsWeight() { << " is nullptr, skip adjust ins weight"; return; } - LoDTensor* nid_tensor = nid_var->GetMutable(); + phi::DenseTensor* nid_tensor = nid_var->GetMutable(); if (nid_tensor == nullptr) { VLOG(0) << "tensor of nid slot var " << adjust_ins_weight_config_.nid_slot() << " is nullptr, skip adjust ins weight"; @@ -303,7 +303,8 @@ void DownpourWorker::AdjustInsWeight() { << " is nullptr, skip adjust ins weight"; return; } - LoDTensor* ins_weight_tensor = ins_weight_var->GetMutable(); + phi::DenseTensor* ins_weight_tensor = + ins_weight_var->GetMutable(); if (ins_weight_tensor == nullptr) { VLOG(0) << "tensor of ins weight tensor " << adjust_ins_weight_config_.ins_weight_slot() @@ -428,14 +429,14 @@ void DownpourWorker::CopyDenseVars() { << dest_var_name; Variable* src_var = thread_scope_->FindVar(src_var_name); CHECK(src_var != nullptr) << src_var_name << " not found"; // NOLINT - LoDTensor* src_tensor = src_var->GetMutable(); + phi::DenseTensor* src_tensor = src_var->GetMutable(); CHECK(src_tensor != nullptr) << src_var_name << " tensor is null"; // NOLINT float* src_data = src_tensor->data(); Variable* dest_var = thread_scope_->FindVar(dest_var_name); CHECK(dest_var != nullptr) << dest_var_name << " not found"; // NOLINT - LoDTensor* dest_tensor = dest_var->GetMutable(); + phi::DenseTensor* dest_tensor = dest_var->GetMutable(); CHECK(dest_tensor != nullptr) << dest_var_name << " tensor is null"; // NOLINT float* dest_data = dest_tensor->data(); @@ -577,7 +578,7 @@ void DownpourWorker::TrainFilesWithProfiler() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } @@ -875,7 +876,7 @@ void DownpourWorker::TrainFiles() { phi::DenseTensor* tensor = nullptr; int64_t len = 0; if (var->IsType()) { - tensor = var->GetMutable(); + tensor = var->GetMutable(); len = tensor->numel(); } else if (var->IsType()) { auto selected_rows = var->GetMutable(); @@ -912,7 +913,7 @@ void DownpourWorker::TrainFiles() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } @@ -973,7 +974,7 @@ void DownpourWorker::TrainFiles() { if (need_to_push_dense_) { if (flag_partial_push_) { Variable* var = (*thread_scope_).FindVar("cond_tag"); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); // check type in python code int64_t* cond_value_batch = tensor->data(); diff --git a/paddle/fluid/framework/downpour_worker_opt.cc b/paddle/fluid/framework/downpour_worker_opt.cc index 9e4b5e9da5..0f921f6ad1 100644 --- a/paddle/fluid/framework/downpour_worker_opt.cc +++ b/paddle/fluid/framework/downpour_worker_opt.cc @@ -433,7 +433,7 @@ void DownpourWorkerOpt::TrainFiles() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } diff --git a/paddle/fluid/framework/executor.cc b/paddle/fluid/framework/executor.cc index fb456fcb68..6ec225ed98 100644 --- a/paddle/fluid/framework/executor.cc +++ b/paddle/fluid/framework/executor.cc @@ -205,7 +205,7 @@ void Executor::Run(const ProgramDesc& pdesc, // Return true if the block has feed operators and holder of matching info. static bool has_feed_operators( const BlockDesc& block, - const std::map& feed_targets, + const std::map& feed_targets, const std::string& feed_holder_name) { size_t feed_count = 0; for (auto* op : block.AllOps()) { @@ -324,7 +324,7 @@ static bool has_fetch_operators( void Executor::Run(const ProgramDesc& program, Scope* scope, - std::map* feed_targets, + std::map* feed_targets, std::map* fetch_targets, bool create_local_scope, bool create_vars, @@ -623,7 +623,7 @@ void Executor::RunPreparedContext(ExecutorPrepareContext* ctx, void Executor::RunPreparedContext( ExecutorPrepareContext* ctx, Scope* scope, - std::map* feed_targets, + std::map* feed_targets, std::map* fetch_targets, bool create_local_scope, bool create_vars, diff --git a/paddle/fluid/framework/executor.h b/paddle/fluid/framework/executor.h index debe927aa7..abf2449b29 100644 --- a/paddle/fluid/framework/executor.h +++ b/paddle/fluid/framework/executor.h @@ -95,7 +95,7 @@ class Executor { // This API is very slow. void Run(const ProgramDesc& program, Scope* scope, - std::map* feed_targets, + std::map* feed_targets, std::map* fetch_targets, bool create_local_scope = true, bool create_vars = true, @@ -103,14 +103,15 @@ class Executor { const std::string& fetch_holder_name = "fetch"); // This API is very slow. - void RunPreparedContext(ExecutorPrepareContext* ctx, - Scope* scope, - std::map* feed_targets, - std::map* fetch_targets, - bool create_local_scope = true, - bool create_vars = true, - const std::string& feed_holder_name = "feed", - const std::string& fetch_holder_name = "fetch"); + void RunPreparedContext( + ExecutorPrepareContext* ctx, + Scope* scope, + std::map* feed_targets, + std::map* fetch_targets, + bool create_local_scope = true, + bool create_vars = true, + const std::string& feed_holder_name = "feed", + const std::string& fetch_holder_name = "fetch"); static std::unique_ptr Prepare( const ProgramDesc& program, diff --git a/paddle/fluid/framework/executor_gc_helper.cc b/paddle/fluid/framework/executor_gc_helper.cc index 3c24ad58d7..39eeabe700 100644 --- a/paddle/fluid/framework/executor_gc_helper.cc +++ b/paddle/fluid/framework/executor_gc_helper.cc @@ -146,8 +146,9 @@ void DeleteUnusedTensors(const Scope &scope, } VLOG(2) << "Erase variable " << var_name; - if (var->IsType()) { - garbages.emplace_back(var->GetMutable()->MoveMemoryHolder()); + if (var->IsType()) { + garbages.emplace_back( + var->GetMutable()->MoveMemoryHolder()); } else if (var->IsType()) { garbages.emplace_back(var->GetMutable() ->mutable_value() diff --git a/paddle/fluid/framework/executor_thread_worker.cc b/paddle/fluid/framework/executor_thread_worker.cc index 8bd0d34bab..f855edc840 100644 --- a/paddle/fluid/framework/executor_thread_worker.cc +++ b/paddle/fluid/framework/executor_thread_worker.cc @@ -90,7 +90,7 @@ std::future DensePullThread::pull_dense(uint64_t table_id) { for (auto i = 0u; i < variables.size(); ++i) { auto& t = variables[i]; Variable* var = _root_scope->FindVar(t); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* w = tensor->data(); paddle::ps::Region reg(w, tensor->numel()); @@ -219,7 +219,8 @@ void ExecutorThreadWorker::SetDevice() { } template -void print_lod_tensor(std::string var_name, const LoDTensor& lod_tensor) { +void print_lod_tensor(std::string var_name, + const phi::DenseTensor& lod_tensor) { auto inspect = lod_tensor.data(); auto element_num = lod_tensor.numel(); @@ -235,7 +236,7 @@ void print_lod_tensor(std::string var_name, const LoDTensor& lod_tensor) { } static void print_fetch_var(Scope* scope, const std::string& var_name) { - auto& tensor = scope->FindVar(var_name)->Get(); + auto& tensor = scope->FindVar(var_name)->Get(); #define PrintLoDTensorCallback(cpp_type, proto_type) \ do { \ @@ -478,7 +479,7 @@ void AsyncExecutorThreadWorker::PushDense(int table_id) { for (auto& t : _param_config->dense_gradient_variable_name[table_id]) { Variable* var = thread_scope_->FindVar(t); CHECK(var != nullptr) << "var[" << t << "] not found"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int count = tensor->numel(); float* g = tensor->data(); paddle::ps::Region reg(g, count); @@ -502,7 +503,7 @@ void AsyncExecutorThreadWorker::PullSparse(int table_id) { // slot_idx = 0 is label TODO for (auto slot_idx = 1u; slot_idx < feed_vec.size(); ++slot_idx) { Variable* var = thread_scope_->FindVar(feed_vec[slot_idx]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* ids = tensor->data(); int len = tensor->numel(); for (auto i = 0u; i < len; ++i) { @@ -546,12 +547,12 @@ void AsyncExecutorThreadWorker::FillSparse(int table_id) { // slot_idx = 0 is label TODO for (auto slot_idx = 1u; slot_idx < feed_vec.size(); ++slot_idx) { Variable* var = thread_scope_->FindVar(feed_vec[slot_idx]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* ids = tensor->data(); int len = tensor->numel(); Variable* var_emb = thread_scope_->FindVar( _param_config->slot_input_vec[table_id][slot_idx - 1]); - LoDTensor* tensor_emb = var_emb->GetMutable(); + phi::DenseTensor* tensor_emb = var_emb->GetMutable(); float* ptr = tensor_emb->mutable_data({len, slot_dim}, platform::CPUPlace()); memset(ptr, 0, sizeof(float) * len * slot_dim); @@ -603,7 +604,7 @@ void AsyncExecutorThreadWorker::PushSparse(int table_id) { CHECK(g_var != nullptr) << "var[" << _param_config->gradient_var[table_id][slot_idx - 1] << "] not found"; - LoDTensor* g_tensor = g_var->GetMutable(); + phi::DenseTensor* g_tensor = g_var->GetMutable(); if (g_tensor == NULL) { LOG(ERROR) << "var[" << _param_config->gradient_var[table_id][slot_idx - 1] @@ -614,7 +615,7 @@ void AsyncExecutorThreadWorker::PushSparse(int table_id) { Variable* var = thread_scope_->FindVar(feed_vec[slot_idx]); CHECK(var != nullptr) << "var[" << feed_vec[slot_idx] << "] not found"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == NULL) { LOG(ERROR) << "var[" << feed_vec[slot_idx] << "] not found"; exit(-1); @@ -661,13 +662,13 @@ void AsyncExecutorThreadWorker::collect_feasign_info(int table_id) { fea_info.resize(feature.size()); const std::vector& feed_vec = thread_reader_->GetUseSlotAlias(); Variable* var = thread_scope_->FindVar(feed_vec[0]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* label = tensor->data(); int global_index = 0; for (auto slot_idx = 1u; slot_idx < feed_vec.size(); ++slot_idx) { Variable* var = thread_scope_->FindVar(feed_vec[slot_idx]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* ids = tensor->data(); int fea_idx = 0; diff --git a/paddle/fluid/framework/feed_fetch_method.cc b/paddle/fluid/framework/feed_fetch_method.cc index edf64aca10..aa3695e7fb 100644 --- a/paddle/fluid/framework/feed_fetch_method.cc +++ b/paddle/fluid/framework/feed_fetch_method.cc @@ -28,7 +28,7 @@ namespace framework { class Variable; void SetFeedVariable(Scope* scope, - const LoDTensor& input, + const phi::DenseTensor& input, const std::string& var_name, size_t index) { // If var_name Variable is not found in GlobalScope, a new variable will @@ -40,7 +40,7 @@ void SetFeedVariable(Scope* scope, feed_inputs.resize(index + 1); } // shared data with input tensor - auto& val = PADDLE_GET(LoDTensor, feed_inputs[index]); + auto& val = PADDLE_GET(phi::DenseTensor, feed_inputs[index]); val.ShareDataWith(input); // set lod val.set_lod(input.lod()); @@ -86,16 +86,17 @@ FetchType& GetFetchVariable(const Scope& scope, return tensor; } -LoDTensor& GetVariableTensor(const Scope& scope, const std::string& var_name) { +phi::DenseTensor& GetVariableTensor(const Scope& scope, + const std::string& var_name) { Variable* var = scope.FindVar(var_name); PADDLE_ENFORCE_NOT_NULL(var, platform::errors::NotFound( "Variable %s is not found in scope.", var_name)); - PADDLE_ENFORCE_EQ(var->IsType(), + PADDLE_ENFORCE_EQ(var->IsType(), true, platform::errors::InvalidArgument( "Only support lod tensor in GetVariableTensor now.")); - return *var->GetMutable(); + return *var->GetMutable(); } } // namespace framework diff --git a/paddle/fluid/framework/feed_fetch_method.h b/paddle/fluid/framework/feed_fetch_method.h index fbebf1cdba..356e6d3ddf 100644 --- a/paddle/fluid/framework/feed_fetch_method.h +++ b/paddle/fluid/framework/feed_fetch_method.h @@ -30,7 +30,7 @@ namespace framework { class Scope; void SetFeedVariable(Scope* scope, - const LoDTensor& input, + const phi::DenseTensor& input, const std::string& var_name, size_t index); @@ -43,7 +43,8 @@ FetchType& GetFetchVariable(const Scope& scope, const std::string& var_name, size_t index); -LoDTensor& GetVariableTensor(const Scope& scope, const std::string& var_name); +phi::DenseTensor& GetVariableTensor(const Scope& scope, + const std::string& var_name); } // namespace framework } // namespace paddle diff --git a/paddle/fluid/framework/feed_fetch_type.h b/paddle/fluid/framework/feed_fetch_type.h index a31435028d..981a303cd1 100644 --- a/paddle/fluid/framework/feed_fetch_type.h +++ b/paddle/fluid/framework/feed_fetch_type.h @@ -22,18 +22,21 @@ limitations under the License. */ namespace paddle { namespace framework { -using FeedType = paddle::variant; +using FeedType = + paddle::variant; using FeedList = std::vector; -using FetchType = paddle:: - variant; +using FetchType = paddle::variant; using FetchList = std::vector; using FetchUnmergedList = std::vector>; using FetchResultType = paddle::variant; inline bool data_is_lod_tensor(const FetchType &data) { - if (data.type() == typeid(LoDTensor)) { + if (data.type() == typeid(phi::DenseTensor)) { return true; } return false; diff --git a/paddle/fluid/framework/fleet/box_wrapper.h b/paddle/fluid/framework/fleet/box_wrapper.h index c4cec547bd..9853c328cd 100644 --- a/paddle/fluid/framework/fleet/box_wrapper.h +++ b/paddle/fluid/framework/fleet/box_wrapper.h @@ -589,7 +589,7 @@ class BoxWrapper { var, platform::errors::NotFound("Error: var %s is not found in scope.", varname.c_str())); - auto& gpu_tensor = var->Get(); + auto& gpu_tensor = var->Get(); auto* gpu_data = gpu_tensor.data(); auto len = gpu_tensor.numel(); data->resize(len); @@ -925,7 +925,7 @@ class BoxWrapper { std::map metric_lists_; std::vector metric_name_list_; std::vector slot_vector_; - std::vector keys_tensor; // Cache for pull_sparse + std::vector keys_tensor; // Cache for pull_sparse bool use_afs_api_ = false; public: diff --git a/paddle/fluid/framework/fleet/box_wrapper_impl.h b/paddle/fluid/framework/fleet/box_wrapper_impl.h index fc171c2b80..d72e418aad 100644 --- a/paddle/fluid/framework/fleet/box_wrapper_impl.h +++ b/paddle/fluid/framework/fleet/box_wrapper_impl.h @@ -47,7 +47,7 @@ void BoxWrapper::PullSparseCase(const paddle::platform::Place& place, #if (defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)) && !defined(_WIN32) VLOG(3) << "Begin copy keys, key_num[" << total_length << "]"; int device_id = place.GetDeviceId(); - LoDTensor& total_keys_tensor = keys_tensor[device_id]; + phi::DenseTensor& total_keys_tensor = keys_tensor[device_id]; uint64_t* total_keys = reinterpret_cast( total_keys_tensor.mutable_data({total_length, 1}, place)); @@ -155,7 +155,7 @@ void BoxWrapper::PushSparseGradCase( } else if (platform::is_gpu_place(place)) { #if (defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)) && !defined(_WIN32) int device_id = place.GetDeviceId(); - LoDTensor& cached_total_keys_tensor = keys_tensor[device_id]; + phi::DenseTensor& cached_total_keys_tensor = keys_tensor[device_id]; uint64_t* total_keys = reinterpret_cast(cached_total_keys_tensor.data()); VLOG(3) << "Begin copy grad tensor to boxps struct"; diff --git a/paddle/fluid/framework/fleet/fleet_wrapper.cc b/paddle/fluid/framework/fleet/fleet_wrapper.cc index b460daa133..3d557506ef 100644 --- a/paddle/fluid/framework/fleet/fleet_wrapper.cc +++ b/paddle/fluid/framework/fleet/fleet_wrapper.cc @@ -172,7 +172,7 @@ void FleetWrapper::HeterPullSparseVars( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << name << " is null"; int64_t* ids = tensor->data(); size_t len = tensor->numel(); @@ -269,7 +269,7 @@ void FleetWrapper::HeterPushSparseVars( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -284,7 +284,7 @@ void FleetWrapper::HeterPushSparseVars( if (g_var == nullptr) { continue; } - LoDTensor* g_tensor = g_var->GetMutable(); + phi::DenseTensor* g_tensor = g_var->GetMutable(); if (g_tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -334,7 +334,7 @@ void FleetWrapper::HeterPushSparseVars( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -444,7 +444,7 @@ void FleetWrapper::PullSparseVarsFromLocal( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << name << " is null"; int64_t* ids = tensor->data(); size_t len = tensor->numel(); @@ -508,7 +508,7 @@ std::future FleetWrapper::PullSparseVarsAsync( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << name << " is null"; int64_t* ids = tensor->data(); size_t len = tensor->numel(); @@ -553,7 +553,7 @@ void FleetWrapper::PullSparseVarsSync( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << name << " is null"; int64_t* ids = tensor->data(); size_t len = tensor->numel(); @@ -615,12 +615,13 @@ void FleetWrapper::PullSparseVarsSync( #endif } -void FleetWrapper::PullSparseToTensorSync(const uint64_t table_id, - int fea_dim, - uint64_t padding_id, - platform::Place place, - std::vector* inputs, - std::vector* outputs) { +void FleetWrapper::PullSparseToTensorSync( + const uint64_t table_id, + int fea_dim, + uint64_t padding_id, + platform::Place place, + std::vector* inputs, + std::vector* outputs) { #ifdef PADDLE_WITH_PSLIB std::vector fea_keys; std::vector pull_result_ptr; @@ -695,7 +696,7 @@ void FleetWrapper::PullDenseVarsAsync( varname = var_names[i] + "pin"; } Variable* var = scope.FindVar(varname); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* w = tensor->data(); paddle::ps::Region reg(w, tensor->numel()); regions[i] = std::move(reg); @@ -716,7 +717,7 @@ void FleetWrapper::PullDenseVarsSync( regions.reserve(var_names.size()); for (auto& t : var_names) { Variable* var = scope.FindVar(t); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* w = tensor->data(); paddle::ps::Region reg(w, tensor->numel()); regions.emplace_back(std::move(reg)); @@ -764,7 +765,7 @@ void FleetWrapper::PushDenseParamSync( for (auto& t : var_names) { Variable* var = scope.FindVar(t); CHECK(var != nullptr) << "var[" << t << "] not found"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* g = tensor->mutable_data(place); paddle::ps::Region reg(g, tensor->numel()); regions.emplace_back(std::move(reg)); @@ -797,12 +798,12 @@ void FleetWrapper::PushDenseVarsAsync( std::vector regions; for (auto& t : var_names) { Variable* var = scope.FindVar(t); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int count = tensor->numel(); float* g_data = tensor->data(); Variable* pin_var = scope.FindVar(t + "pin"); - LoDTensor* pin_tensor = pin_var->GetMutable(); + phi::DenseTensor* pin_tensor = pin_var->GetMutable(); float* pin_g = pin_tensor->mutable_data(tensor->dims(), platform::CUDAPinnedPlace()); memory::Copy(platform::CUDAPinnedPlace(), @@ -859,12 +860,12 @@ void FleetWrapper::PushDenseVarsAsync( std::vector regions; for (auto& t : var_names) { Variable* var = scope.FindVar(t); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int count = tensor->numel(); float* g_data = tensor->data(); Variable* pin_var = scope.FindVar(t + "pin"); - LoDTensor* pin_tensor = pin_var->GetMutable(); + phi::DenseTensor* pin_tensor = pin_var->GetMutable(); float* pin_g = pin_tensor->mutable_data(tensor->dims(), platform::CPUPlace()); memory::Copy( @@ -908,7 +909,7 @@ void FleetWrapper::PushDenseVarsAsync( std::vector regions; for (auto& t : var_names) { Variable* var = scope.FindVar(t); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int count = tensor->numel(); float* g = tensor->data(); if (scale_datanorm >= 0) { @@ -988,7 +989,7 @@ void FleetWrapper::PushSparseVarsWithLabelAsync( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -1015,7 +1016,7 @@ void FleetWrapper::PushSparseVarsWithLabelAsync( if (g_var == nullptr) { continue; } - LoDTensor* g_tensor = g_var->GetMutable(); + phi::DenseTensor* g_tensor = g_var->GetMutable(); if (g_tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -1065,7 +1066,7 @@ void FleetWrapper::PushSparseVarsWithLabelAsync( if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { LOG(ERROR) << "tensor of var[" << sparse_key_names[i] << "] is null"; exit(-1); @@ -1109,8 +1110,8 @@ void FleetWrapper::PushSparseFromTensorWithLabelAsync( const std::string& click_name, platform::Place place, const std::vector& input_names, - std::vector* inputs, - std::vector* outputs) { + std::vector* inputs, + std::vector* outputs) { #ifdef PADDLE_WITH_PSLIB int show_index = 0; int click_index = 1; @@ -1302,12 +1303,12 @@ void FleetWrapper::LoadFromPaddleModel(Scope& scope, for (auto& t : old_param_list) { Variable* old_var = old_scope->Var(t); // old model data, here we assume data type is float - LoDTensor* old_tensor = old_var->GetMutable(); + phi::DenseTensor* old_tensor = old_var->GetMutable(); float* old_data = old_tensor->data(); // new model data, here we assume data type is float Variable* var = scope.FindVar(t); CHECK(var != nullptr) << "var[" << t << "] not found"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* data = tensor->data(); // copy from old data to new data if (old_tensor->numel() > tensor->numel()) { @@ -1619,7 +1620,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id, Variable* var = scope->FindVar(name); CHECK(var != nullptr) << "var[" << name << "] not found"; VLOG(0) << "prepare shrink dense batch_sum"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* g = tensor->data(); // show_batch_sum += N * log(decay) @@ -1629,7 +1630,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id, Variable* var_size = scope->FindVar(size_name); CHECK(var_size != nullptr) << "var[" << size_name << "] not found"; VLOG(3) << "shrink dense batch_sum: " << name << ", " << size_name; - float* g_size = var_size->GetMutable()->data(); + float* g_size = var_size->GetMutable()->data(); for (int k = 0; k < tensor->numel(); k += emb_dim) { g[k] = g[k] + g_size[k] * log(decay); @@ -1639,7 +1640,7 @@ void FleetWrapper::ShrinkDenseTable(int table_id, } else { Variable* var = scope->FindVar(name); CHECK(var != nullptr) << "var[" << name << "] not found"; - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* g = tensor->data(); paddle::ps::Region reg(g, tensor->numel()); regions.emplace_back(std::move(reg)); diff --git a/paddle/fluid/framework/fleet/fleet_wrapper.h b/paddle/fluid/framework/fleet/fleet_wrapper.h index 990178feab..b3af181e42 100644 --- a/paddle/fluid/framework/fleet/fleet_wrapper.h +++ b/paddle/fluid/framework/fleet/fleet_wrapper.h @@ -142,12 +142,13 @@ class FleetWrapper { // Pull sparse variables from server in sync mode // pull immediately to tensors - void PullSparseToTensorSync(const uint64_t table_id, - int fea_dim, - uint64_t padding_id, - platform::Place place, - std::vector* inputs, // NOLINT - std::vector* outputs); // NOLINT + void PullSparseToTensorSync( + const uint64_t table_id, + int fea_dim, + uint64_t padding_id, + platform::Place place, + std::vector* inputs, // NOLINT + std::vector* outputs); // NOLINT // pull dense variables from server in sync mod // Param: scope, table_id, var_names @@ -256,8 +257,8 @@ class FleetWrapper { const std::string& click_name, platform::Place place, const std::vector& input_names, - std::vector* inputs, // NOLINT - std::vector* outputs); // NOLINT + std::vector* inputs, // NOLINT + std::vector* outputs); // NOLINT // Push sparse variables to server in Async mode // Param: scope, table_id, fea_keys, sparse_grad_names @@ -298,7 +299,7 @@ class FleetWrapper { // flush all push requests void ClientFlush(); // load from paddle model - void LoadFromPaddleModel(Scope& scope, + void LoadFromPaddleModel(Scope& scope, // NOLINT const uint64_t table_id, // NOLINT std::vector var_list, std::string model_path, diff --git a/paddle/fluid/framework/fleet/heter_wrapper.cc b/paddle/fluid/framework/fleet/heter_wrapper.cc index e50c1596b2..51f9a445f7 100644 --- a/paddle/fluid/framework/fleet/heter_wrapper.cc +++ b/paddle/fluid/framework/fleet/heter_wrapper.cc @@ -89,7 +89,7 @@ void HeterWrapper::SerializeToReq(const std::string& varname, if (var == nullptr) { return; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); req_var->set_varname(varname); req_var->set_type(LOD_TENSOR); req_var->set_data_type(static_cast( @@ -148,7 +148,7 @@ void HeterWrapper::DeSerializeToTensor(Scope* scope, gpuStream_t stream) { // const VariableMessage& req_var = request->vars(); auto* var = scope->FindVar(req_var.varname()); - auto* tensor = var->GetMutable(); + auto* tensor = var->GetMutable(); std::vector vec_dim; for (auto& x : req_var.dims()) { @@ -193,7 +193,7 @@ void HeterWrapper::DeSerializeToTensor(Scope* scope, platform::Place place) { // const VariableMessage& req_var = request->vars(); auto* var = scope->FindVar(req_var.varname()); - auto* tensor = var->GetMutable(); + auto* tensor = var->GetMutable(); std::vector vec_dim; for (auto& x : req_var.dims()) { diff --git a/paddle/fluid/framework/fleet/metrics.h b/paddle/fluid/framework/fleet/metrics.h index 309e47a360..6212eec1ab 100644 --- a/paddle/fluid/framework/fleet/metrics.h +++ b/paddle/fluid/framework/fleet/metrics.h @@ -183,7 +183,7 @@ class Metric { var, platform::errors::NotFound("Error: var %s is not found in scope.", varname.c_str())); - auto& cpu_tensor = var->Get(); + auto& cpu_tensor = var->Get(); *data = cpu_tensor.data(); *len = cpu_tensor.numel(); } @@ -197,7 +197,7 @@ class Metric { var, platform::errors::NotFound("Error: var %s is not found in scope.", varname.c_str())); - auto& cpu_tensor = var->Get(); + auto& cpu_tensor = var->Get(); auto* cpu_data = cpu_tensor.data(); auto len = cpu_tensor.numel(); data->resize(len); diff --git a/paddle/fluid/framework/fleet/nccl_wrapper.cc b/paddle/fluid/framework/fleet/nccl_wrapper.cc index f81ee5402d..640f7dd08d 100644 --- a/paddle/fluid/framework/fleet/nccl_wrapper.cc +++ b/paddle/fluid/framework/fleet/nccl_wrapper.cc @@ -69,7 +69,7 @@ void NCCLWrapper::SyncVar(const int root_rank, #if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL) for (auto& name : var_names) { auto var = scope.FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int32_t total_size = tensor->numel(); PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast( reinterpret_cast(tensor->data()), diff --git a/paddle/fluid/framework/fleet/ps_gpu_wrapper.cc b/paddle/fluid/framework/fleet/ps_gpu_wrapper.cc index 40597aed31..2cf1714aaa 100644 --- a/paddle/fluid/framework/fleet/ps_gpu_wrapper.cc +++ b/paddle/fluid/framework/fleet/ps_gpu_wrapper.cc @@ -140,7 +140,7 @@ void PSGPUWrapper::PreBuildTask(std::shared_ptr gpu_task) { if (!gpu_graph_mode_) { if (data_set_name.find("SlotRecordDataset") != std::string::npos) { VLOG(0) << "ps_gpu_wrapper use SlotRecordDataset"; - SlotRecordDataset* dataset = (SlotRecordDataset*)(dataset_); + SlotRecordDataset* dataset = (SlotRecordDataset*)(dataset_); // NOLINT auto input_channel = dataset->GetInputChannel(); VLOG(0) << "psgpu wrapperinputslotchannle size: " << input_channel->Size(); @@ -194,7 +194,7 @@ void PSGPUWrapper::PreBuildTask(std::shared_ptr gpu_task) { } else { CHECK(data_set_name.find("MultiSlotDataset") != std::string::npos); VLOG(0) << "ps_gpu_wrapper use MultiSlotDataset"; - MultiSlotDataset* dataset = (MultiSlotDataset*)(dataset_); + MultiSlotDataset* dataset = (MultiSlotDataset*)(dataset_); // NOLINT auto input_channel = dataset->GetInputChannel(); const std::deque& vec_data = input_channel->GetData(); @@ -235,7 +235,7 @@ void PSGPUWrapper::PreBuildTask(std::shared_ptr gpu_task) { } } else { VLOG(0) << "PreBuild in GpuGraph mode"; - SlotRecordDataset* dataset = (SlotRecordDataset*)(dataset_); + SlotRecordDataset* dataset = (SlotRecordDataset*)(dataset_); // NOLINT const std::vector& vec_data = dataset->GetGpuGraphTotalKeys(); total_len = vec_data.size(); @@ -264,7 +264,7 @@ void PSGPUWrapper::PreBuildTask(std::shared_ptr gpu_task) { iter++) { uint64_t cur_key = *iter; int shard_id = cur_key % thread_keys_shard_num_; - // TODO: feasign <-> slot <-> multi_dim + // TODO(fengdanlei): feasign <-> slot <-> multi_dim this->thread_dim_keys_[i][shard_id][0].insert(cur_key); } }; @@ -786,9 +786,9 @@ void PSGPUWrapper::BuildGPUTask(std::shared_ptr gpu_task) { size_t left = 0, right = 0; size_t real_len = len_per_thread; - if ((size_t)z < remain) real_len++; + if ((size_t)z < remain) real_len++; // NOLINT - if ((size_t)z < remain) { + if ((size_t)z < remain) { // NOLINT left = z * (len_per_thread + 1); right = left + real_len; } else { @@ -799,7 +799,7 @@ void PSGPUWrapper::BuildGPUTask(std::shared_ptr gpu_task) { for (size_t k = left; k < right; k++) { #ifdef PADDLE_WITH_PSLIB - float* val = (float*)(mem_pool->mem_address(k)); + float* val = (float*)(mem_pool->mem_address(k)); // NOLINT float* ptr_val = device_dim_ptrs[k]->data(); size_t dim = device_dim_ptrs[k]->size(); val->delta_score = @@ -809,8 +809,8 @@ void PSGPUWrapper::BuildGPUTask(std::shared_ptr gpu_task) { DownpourCtrDymfFeatureValue::show_index()]; val->clk = ptr_val[paddle::ps::DownpourCtrDymfAccessor:: DownpourCtrDymfFeatureValue::click_index()]; - val->slot = int(ptr_val[paddle::ps::DownpourCtrDymfAccessor:: - DownpourCtrDymfFeatureValue::slot_index()]); + val->slot = int(ptr_val[paddle::ps::DownpourCtrDymfAccessor:: // NOLINT + DownpourCtrDymfFeatureValue::slot_index()]); val->lr = ptr_val[paddle::ps::DownpourCtrDymfAccessor:: DownpourCtrDymfFeatureValue::embed_w_index()]; val->lr_g2sum = @@ -818,7 +818,7 @@ void PSGPUWrapper::BuildGPUTask(std::shared_ptr gpu_task) { DownpourCtrDymfFeatureValue::embed_g2sum_index()]; // TODO(xuefeng) set mf_dim while using DownpourCtrDymfAccessor ptr_val[paddle::ps::DownpourCtrDymfAccessor::DownpourCtrDymfFeatureValue:: - mf_dim_index()] = float(mf_dim); + mf_dim_index()] = float(mf_dim); // NOLINT val->mf_dim = mf_dim; if (dim > 8) { // CpuPS alreay expand as mf_dim val->mf_size = mf_dim + 1; @@ -1025,7 +1025,8 @@ void PSGPUWrapper::EndPass() { VLOG(0) << "dump pool to cpu table: " << i << "with mf dim: " << mf_dim << " key_len :" << len << " feature_value_size:" << feature_value_size; - char* test_build_values = (char*)malloc(feature_value_size * real_len); + char* test_build_values = + (char*)malloc(feature_value_size * real_len); // NOLINT uint64_t offset = left * feature_value_size; cudaMemcpy(test_build_values, hbm_pool->mem() + offset, @@ -1038,9 +1039,9 @@ void PSGPUWrapper::EndPass() { continue; } size_t local_offset = (i - left) * feature_value_size; - float* gpu_val = (float*)(test_build_values + local_offset); + float* gpu_val = (float*)(test_build_values + local_offset); // NOLINT #ifdef PADDLE_WITH_PSLIB - // TODO: PSLIB DumpFill + // TODO(fengdanlei): PSLIB DumpFill #endif #ifdef PADDLE_WITH_PSCORE accessor_wrapper_ptr->DumpFill(gpu_val, cpu_table_accessor_, mf_dim); @@ -1239,7 +1240,7 @@ void PSGPUWrapper::PullSparse(const paddle::platform::Place& place, auto buf = memory::Alloc(place, total_length * feature_value_size); float* total_values_gpu = reinterpret_cast(buf->ptr()); VLOG(3) << "Begin copy keys, key_num[" << total_length << "]"; - LoDTensor& total_keys_tensor = keys_tensor[devid_2_index]; + phi::DenseTensor& total_keys_tensor = keys_tensor[devid_2_index]; uint64_t* total_keys = reinterpret_cast(total_keys_tensor.mutable_data( {int64_t(total_length), 1}, place)); @@ -1309,7 +1310,7 @@ void PSGPUWrapper::PullSparse(const paddle::platform::Place& place, VLOG(3) << "Begin copy keys, key_num[" << total_length << "]"; int device_id = place.GetDeviceId(); int devid_2_index = HeterPs_->get_index_by_devid(device_id); - LoDTensor& total_keys_tensor = keys_tensor[devid_2_index]; + phi::DenseTensor& total_keys_tensor = keys_tensor[devid_2_index]; uint64_t* total_keys = reinterpret_cast(total_keys_tensor.mutable_data( {int64_t(total_length), 1}, place)); @@ -1489,7 +1490,7 @@ void PSGPUWrapper::PushSparseGrad(const paddle::platform::Place& place, << "grad_value_size:" << grad_value_size; float* total_grad_values_gpu = reinterpret_cast(buf->ptr()); - LoDTensor& total_keys_tensor = keys_tensor[devid_2_index]; + phi::DenseTensor& total_keys_tensor = keys_tensor[devid_2_index]; uint64_t* total_keys = reinterpret_cast(total_keys_tensor.data()); VLOG(3) << "Begin copy grad tensor to gpups struct"; @@ -1526,7 +1527,7 @@ void PSGPUWrapper::PushSparseGrad(const paddle::platform::Place& place, VLOG(3) << "Push Sparse Max mf dimention: " << max_mf_dim_ << "grad_value_size:" << grad_value_size; float* total_grad_values_gpu = reinterpret_cast(buf->ptr()); - LoDTensor& total_keys_tensor = keys_tensor[devid_2_index]; + phi::DenseTensor& total_keys_tensor = keys_tensor[devid_2_index]; uint64_t* total_keys = reinterpret_cast(total_keys_tensor.data()); VLOG(3) << "Begin copy grad tensor to xpups struct"; diff --git a/paddle/fluid/framework/fleet/ps_gpu_wrapper.h b/paddle/fluid/framework/fleet/ps_gpu_wrapper.h index 45a406d2fe..96dc86cea3 100644 --- a/paddle/fluid/framework/fleet/ps_gpu_wrapper.h +++ b/paddle/fluid/framework/fleet/ps_gpu_wrapper.h @@ -649,7 +649,7 @@ class PSGPUWrapper { std::vector>>> local_tables_; HeterPsBase* HeterPs_; - std::vector keys_tensor; // Cache for pull_sparse + std::vector keys_tensor; // Cache for pull_sparse std::shared_ptr resource_; int32_t sleep_seconds_before_fail_exit_; std::vector slot_vector_; diff --git a/paddle/fluid/framework/heter_section_worker.cc b/paddle/fluid/framework/heter_section_worker.cc index a17cec8419..914a172039 100644 --- a/paddle/fluid/framework/heter_section_worker.cc +++ b/paddle/fluid/framework/heter_section_worker.cc @@ -32,10 +32,11 @@ void SetMicroId(paddle::framework::Scope* scope, auto* ptr = scope->Var("microbatch_id"); InitializeVariable(ptr, proto::VarType::LOD_TENSOR); framework::Variable* var = scope->FindVar("microbatch_id"); - PADDLE_ENFORCE_EQ(var->IsType(), - 1, - platform::errors::InvalidArgument( - "the type of microbatch_id should be LoDTensor")); + PADDLE_ENFORCE_EQ( + var->IsType(), + 1, + platform::errors::InvalidArgument( + "the type of microbatch_id should be phi::DenseTensor")); auto* tensor = var->GetMutable(); std::vector dims{1}; tensor->Resize(phi::make_ddim(dims)); diff --git a/paddle/fluid/framework/heter_service.proto b/paddle/fluid/framework/heter_service.proto index c8c9ec80b3..b1edbedf92 100644 --- a/paddle/fluid/framework/heter_service.proto +++ b/paddle/fluid/framework/heter_service.proto @@ -15,7 +15,7 @@ syntax = "proto2"; package paddle.framework; option cc_generic_services = true; -// It can be: LoDTensor、SelectedRows or NCCL_ID +// It can be: phi::DenseTensor、SelectedRows or NCCL_ID enum VarType { LOD_TENSOR = 0; SELECTED_ROWS = 1; diff --git a/paddle/fluid/framework/hetercpu_worker.cc b/paddle/fluid/framework/hetercpu_worker.cc index 34384a4091..f741baa0f3 100644 --- a/paddle/fluid/framework/hetercpu_worker.cc +++ b/paddle/fluid/framework/hetercpu_worker.cc @@ -54,9 +54,10 @@ void HeterTask::PackTask(Scope* thread_scope, auto& use_slots = reader->GetUseSlotAlias(); for (size_t i = 0; i < use_slots.size(); ++i) { Variable* thread_var = thread_scope->FindVar(use_slots[i]); - LoDTensor* thread_tensor = thread_var->GetMutable(); + phi::DenseTensor* thread_tensor = + thread_var->GetMutable(); Variable* task_var = scope_->FindVar(use_slots[i]); - LoDTensor* task_tensor = task_var->GetMutable(); + phi::DenseTensor* task_tensor = task_var->GetMutable(); TensorCopy(*thread_tensor, platform::CPUPlace(), task_tensor); auto& tensor_lod = thread_tensor->lod()[0]; LoD thread_lod{tensor_lod}; @@ -198,7 +199,7 @@ void HeterCpuWorker::SetNeedDump(bool need_dump_field) { } // template -// std::string PrintLodTensorType(LoDTensor* tensor, +// std::string PrintLodTensorType(phi::DenseTensor* tensor, // int64_t start, int64_t end) { // auto count = tensor->numel(); // if (start < 0 || end > count) { @@ -212,7 +213,7 @@ void HeterCpuWorker::SetNeedDump(bool need_dump_field) { // return os.str(); // } // -// std::string PrintLodTensorIntType(LoDTensor* tensor, int64_t start, +// std::string PrintLodTensorIntType(phi::DenseTensor* tensor, int64_t start, // int64_t end) { // auto count = tensor->numel(); // if (start < 0 || end > count) { @@ -226,7 +227,8 @@ void HeterCpuWorker::SetNeedDump(bool need_dump_field) { // return os.str(); // } // -// std::string PrintLodTensor(LoDTensor* tensor, int64_t start, int64_t end) { +// std::string PrintLodTensor(phi::DenseTensor* tensor, int64_t start, int64_t +// end) { // std::string out_val; // if (tensor->type() == proto::VarType::FP32) { // out_val = PrintLodTensorType(tensor, start, end); @@ -240,7 +242,8 @@ void HeterCpuWorker::SetNeedDump(bool need_dump_field) { // return out_val; // } // -// std::pair GetTensorBound(LoDTensor* tensor, int index) { +// std::pair GetTensorBound(phi::DenseTensor* tensor, int +// index) { // auto& dims = tensor->dims(); // if (tensor->lod().size() != 0) { // auto& lod = tensor->lod()[0]; @@ -250,7 +253,7 @@ void HeterCpuWorker::SetNeedDump(bool need_dump_field) { // } // } // -// bool CheckValidOutput(LoDTensor* tensor, size_t batch_size) { +// bool CheckValidOutput(phi::DenseTensor* tensor, size_t batch_size) { // auto& dims = tensor->dims(); // if (dims.size() != 2) return false; // if (tensor->lod().size() != 0) { @@ -275,7 +278,7 @@ void HeterCpuWorker::DumpParam() { // if (var == nullptr) { // continue; // } - // LoDTensor* tensor = var->GetMutable(); + // phi::DenseTensor* tensor = var->GetMutable(); // int64_t len = tensor->numel(); // os += PrintLodTensor(tensor, 0, len); // writer_ << os; @@ -302,7 +305,7 @@ void HeterCpuWorker::CollectLabelInfo(std::shared_ptr task, Scope* scope = task->scope_; feature_label.resize(feature.size()); Variable* var = scope->FindVar(label_var_name_[table_id]); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); int64_t* label_ptr = tensor->data(); size_t global_index = 0; @@ -313,7 +316,7 @@ void HeterCpuWorker::CollectLabelInfo(std::shared_ptr task, if (fea_var == nullptr) { continue; } - LoDTensor* tensor = fea_var->GetMutable(); + phi::DenseTensor* tensor = fea_var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << sparse_key_names_[table_id][i] << " is null"; @@ -365,7 +368,7 @@ void HeterCpuWorker::FillSparseValue(std::shared_ptr task, if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); CHECK(tensor != nullptr) << "tensor of var " << slot_name << " is null"; int64_t* ids = tensor->data(); int len = tensor->numel(); @@ -373,7 +376,7 @@ void HeterCpuWorker::FillSparseValue(std::shared_ptr task, if (var_emb == nullptr) { continue; } - LoDTensor* tensor_emb = var_emb->GetMutable(); + phi::DenseTensor* tensor_emb = var_emb->GetMutable(); float* ptr = tensor_emb->mutable_data({len, table.emb_dim()}, place_); // memset(ptr, 0, sizeof(float) * len * table.emb_dim()); @@ -448,7 +451,7 @@ void HeterCpuWorker::AdjustInsWeight(std::shared_ptr task) { << " is nullptr, skip adjust ins weight"; return; } - LoDTensor* nid_tensor = nid_var->GetMutable(); + phi::DenseTensor* nid_tensor = nid_var->GetMutable(); if (nid_tensor == nullptr) { VLOG(0) << "tensor of nid slot var " << adjust_ins_weight_config_.nid_slot() << " is nullptr, skip adjust ins weight"; @@ -461,7 +464,8 @@ void HeterCpuWorker::AdjustInsWeight(std::shared_ptr task) { << " is nullptr, skip adjust ins weight"; return; } - LoDTensor* ins_weight_tensor = ins_weight_var->GetMutable(); + phi::DenseTensor* ins_weight_tensor = + ins_weight_var->GetMutable(); if (ins_weight_tensor == nullptr) { VLOG(0) << "tensor of ins weight tensor " << adjust_ins_weight_config_.ins_weight_slot() @@ -584,14 +588,14 @@ void HeterCpuWorker::CopyDenseVars() { << dest_var_name; Variable* src_var = thread_scope_->FindVar(src_var_name); CHECK(src_var != nullptr) << src_var_name << " not found"; // NOLINT - LoDTensor* src_tensor = src_var->GetMutable(); + phi::DenseTensor* src_tensor = src_var->GetMutable(); CHECK(src_tensor != nullptr) << src_var_name << " tensor is null"; // NOLINT float* src_data = src_tensor->data(); Variable* dest_var = thread_scope_->FindVar(dest_var_name); CHECK(dest_var != nullptr) << dest_var_name << " not found"; // NOLINT - LoDTensor* dest_tensor = dest_var->GetMutable(); + phi::DenseTensor* dest_tensor = dest_var->GetMutable(); CHECK(dest_tensor != nullptr) << dest_var_name << " tensor is null"; // NOLINT float* dest_data = dest_tensor->data(); @@ -797,7 +801,7 @@ void HeterCpuWorker::TrainFilesWithProfiler() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } @@ -1085,7 +1089,7 @@ void HeterCpuWorker::TrainFiles() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr) { continue; } @@ -1154,7 +1158,7 @@ void HeterCpuWorker::TrainFiles() { // if (var == nullptr) { // continue; // } - // LoDTensor* tensor = var->GetMutable(); + // phi::DenseTensor* tensor = var->GetMutable(); // if (!CheckValidOutput(tensor, batch_size)) { // continue; // } diff --git a/paddle/fluid/framework/heterxpu_trainer.cc b/paddle/fluid/framework/heterxpu_trainer.cc index 0afeecd06b..2828e86d40 100644 --- a/paddle/fluid/framework/heterxpu_trainer.cc +++ b/paddle/fluid/framework/heterxpu_trainer.cc @@ -133,10 +133,10 @@ void HeterXpuTrainer::CreateThreadParam(const ProgramDesc& program, int num) { if (var->Persistable()) { auto name = var->Name(); Variable* root_var = root_scope_->FindVar(name); - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); auto* ptr = scope->Var(name); InitializeVariable(ptr, proto::VarType::LOD_TENSOR); - LoDTensor* thread_tensor = ptr->GetMutable(); + phi::DenseTensor* thread_tensor = ptr->GetMutable(); #define HeterMemcpyFunc(cpp_type, proto_type) \ do { \ @@ -167,8 +167,8 @@ void HeterXpuTrainer::CreateThreadParam(const ProgramDesc& program, int num) { #ifdef PADDLE_WITH_CUDA template -void HeterXpuTrainer::HeterMemCpy(LoDTensor* thread_tensor, - LoDTensor* root_tensor, +void HeterXpuTrainer::HeterMemCpy(phi::DenseTensor* thread_tensor, + phi::DenseTensor* root_tensor, const paddle::platform::Place& thread_place, cudaStream_t stream) { T* thread_ptr = @@ -194,8 +194,8 @@ void HeterXpuTrainer::HeterMemCpy(LoDTensor* thread_tensor, #ifdef PADDLE_WITH_XPU template -void HeterXpuTrainer::HeterMemCpy(LoDTensor* thread_tensor, - LoDTensor* root_tensor, +void HeterXpuTrainer::HeterMemCpy(phi::DenseTensor* thread_tensor, + phi::DenseTensor* root_tensor, const paddle::platform::Place& thread_place) { T* thread_ptr = thread_tensor->mutable_data(root_tensor->dims(), thread_place); @@ -319,7 +319,7 @@ int HeterXpuTrainer::EndPass(const HeterRequest* request, if (root_var == nullptr) { continue; } - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); for (size_t j = 0; j < place_scopes_.size(); j++) { Scope* cur_thread_scope = place_scopes_[j]; @@ -328,7 +328,8 @@ int HeterXpuTrainer::EndPass(const HeterRequest* request, if (thread_var == nullptr) { continue; } - LoDTensor* thread_tensor = thread_var->GetMutable(); + phi::DenseTensor* thread_tensor = + thread_var->GetMutable(); // if (root_tensor->numel() != thread_tensor->numel()) { // continue; // } @@ -421,12 +422,12 @@ int HeterXpuTrainer::EndPass(const HeterRequest* request, } template -void HeterXpuTrainer::MergeToRootScope(LoDTensor* root_tensor, - LoDTensor* tensor) { - LoDTensor tmp_root; +void HeterXpuTrainer::MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* tensor) { + phi::DenseTensor tmp_root; TensorCopy(*root_tensor, platform::CPUPlace(), &tmp_root); T* tmp_root_data = tmp_root.data(); - LoDTensor tmp_tensor; + phi::DenseTensor tmp_tensor; TensorCopy(*tensor, platform::CPUPlace(), &tmp_tensor); T* data = tmp_tensor.data(); for (int i = 0; i < tmp_tensor.numel(); i++) { diff --git a/paddle/fluid/framework/hogwild_worker.cc b/paddle/fluid/framework/hogwild_worker.cc index 777ca26e3e..57da94da86 100644 --- a/paddle/fluid/framework/hogwild_worker.cc +++ b/paddle/fluid/framework/hogwild_worker.cc @@ -74,13 +74,14 @@ void HogwildWorker::CreateThreadScope(const ProgramDesc &program) { InitializeVariable(ptr, var->GetType()); if (stat_var_name_map_.find(var->Name()) != stat_var_name_map_.end() && thread_id_ != 0) { - int tensor_dim = - root_scope_->FindVar(var->Name())->GetMutable()->numel(); + int tensor_dim = root_scope_->FindVar(var->Name()) + ->GetMutable() + ->numel(); auto *ptr1 = thread_scope_->Var(var->Name()); InitializeVariable(ptr1, var->GetType()); - LoDTensor *thread_tensor = ptr1->GetMutable(); - LoDTensor *root_tensor = - root_scope_->FindVar(var->Name())->GetMutable(); + phi::DenseTensor *thread_tensor = ptr1->GetMutable(); + phi::DenseTensor *root_tensor = + root_scope_->FindVar(var->Name())->GetMutable(); #define MemsetCallback(cpp_type, proto_type) \ do { \ if (framework::TransToProtoVarType(root_tensor->dtype()) == proto_type) { \ @@ -97,8 +98,8 @@ void HogwildWorker::CreateThreadScope(const ProgramDesc &program) { } template -void HogwildWorker::SetZero(LoDTensor *tensor, - LoDTensor *root_tensor, +void HogwildWorker::SetZero(phi::DenseTensor *tensor, + phi::DenseTensor *root_tensor, int tensor_dim) { T *ptr = tensor->mutable_data(root_tensor->dims(), platform::CPUPlace()); memset(ptr, 0, sizeof(T) * tensor_dim); diff --git a/paddle/fluid/framework/infershape_utils.cc b/paddle/fluid/framework/infershape_utils.cc index 2b9584f47f..fe4ee561c7 100644 --- a/paddle/fluid/framework/infershape_utils.cc +++ b/paddle/fluid/framework/infershape_utils.cc @@ -379,12 +379,12 @@ void CompatMetaTensor::share_lod(const MetaTensor& meta_tensor) { static_cast(meta_tensor).GetRuntimeLoD(); } else { // NOTE(chenweihang): do nothing - // only LoDTensor need to share lod + // only phi::DenseTensor need to share lod } } else { auto* var = PADDLE_GET(VarDesc*, var_); if (!meta_tensor.is_dense() && !meta_tensor.is_tensor_array()) { - VLOG(3) << "input metatensor is not LoDTensor or LoDTensorArray."; + VLOG(3) << "input metatensor is not phi::DenseTensor or LoDTensorArray."; return; } if (var) { @@ -415,7 +415,7 @@ void CompatMetaTensor::share_meta(const MetaTensor& meta_tensor) { share_dims(meta_tensor); set_dtype(meta_tensor.dtype()); set_layout(meta_tensor.layout()); - // special case: share lod of LoDTensor + // special case: share lod of phi::DenseTensor share_lod(meta_tensor); } diff --git a/paddle/fluid/framework/infershape_utils.h b/paddle/fluid/framework/infershape_utils.h index 9d284dd8a2..17587ba3ae 100644 --- a/paddle/fluid/framework/infershape_utils.h +++ b/paddle/fluid/framework/infershape_utils.h @@ -72,7 +72,7 @@ class CompatMetaTensor : public phi::MetaTensor { private: const LoD& GetRuntimeLoD() const { auto* var = PADDLE_GET_CONST(Variable*, var_); - return var->Get().lod(); + return var->Get().lod(); } int32_t GetCompileTimeLoD() const { diff --git a/paddle/fluid/framework/ir/attention_lstm_fuse_pass.cc b/paddle/fluid/framework/ir/attention_lstm_fuse_pass.cc index 1e84646378..8225840a69 100644 --- a/paddle/fluid/framework/ir/attention_lstm_fuse_pass.cc +++ b/paddle/fluid/framework/ir/attention_lstm_fuse_pass.cc @@ -183,21 +183,21 @@ void AttentionLSTMFusePass::FindWhileOp(Graph* graph) const { CHECK_P4(x0, x1, x2, x3); \ CHECK_P1(x4); -void PrepareLSTMWeight(const LoDTensor& W_forget_w0, - const LoDTensor& W_forget_w1, - const LoDTensor& W_input_w0, - const LoDTensor& W_input_w1, - const LoDTensor& W_output_w0, - const LoDTensor& W_output_w1, - const LoDTensor& W_cell_w0, - const LoDTensor& W_cell_w1, - LoDTensor* out); - -void PrepareLSTMBias(const LoDTensor& B_forget, - const LoDTensor& B_input, - const LoDTensor& B_output, - const LoDTensor& B_cell, - LoDTensor* out); +void PrepareLSTMWeight(const phi::DenseTensor& W_forget_w0, + const phi::DenseTensor& W_forget_w1, + const phi::DenseTensor& W_input_w0, + const phi::DenseTensor& W_input_w1, + const phi::DenseTensor& W_output_w0, + const phi::DenseTensor& W_output_w1, + const phi::DenseTensor& W_cell_w0, + const phi::DenseTensor& W_cell_w1, + phi::DenseTensor* out); + +void PrepareLSTMBias(const phi::DenseTensor& B_forget, + const phi::DenseTensor& B_input, + const phi::DenseTensor& B_output, + const phi::DenseTensor& B_cell, + phi::DenseTensor* out); void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { // Check parameters @@ -209,8 +209,8 @@ void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { // Create new parameters. // AddInput - scope.Var(param.LSTMWeight)->GetMutable(); - scope.Var(param.LSTMBias)->GetMutable(); + scope.Var(param.LSTMWeight)->GetMutable(); + scope.Var(param.LSTMBias)->GetMutable(); // AddOutput #define IR_NODE(x) \ VarDesc key_##x(param.x); \ @@ -226,20 +226,20 @@ void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { IR_NODE(LSTMOUT); #undef IR_NODE -#define GATE_W(name__) \ - auto* W_##name__##_w0 = scope.FindVar(#name__ ".w_0"); \ - auto* W_##name__##_w1 = scope.FindVar(#name__ ".w_1"); \ - auto* W_##name__##_b0 = scope.FindVar(#name__ ".b_0"); \ - CHECK_P3(W_##name__##_w0, W_##name__##_w1, W_##name__##_b0); \ - VLOG(4) << #name__ "_w0" \ - << " shape: " << W_##name__##_w0->Get().dims(); \ - VLOG(4) << #name__ "_w1" \ - << " shape: " << W_##name__##_w1->Get().dims(); \ - VLOG(4) << #name__ "_b0" \ - << " shape: " << W_##name__##_b0->Get().dims(); \ - auto& W_##name__##_w0_t = W_##name__##_w0->Get(); \ - auto& W_##name__##_w1_t = W_##name__##_w1->Get(); \ - auto& W_##name__##_b0_t = W_##name__##_b0->Get(); +#define GATE_W(name__) \ + auto* W_##name__##_w0 = scope.FindVar(#name__ ".w_0"); \ + auto* W_##name__##_w1 = scope.FindVar(#name__ ".w_1"); \ + auto* W_##name__##_b0 = scope.FindVar(#name__ ".b_0"); \ + CHECK_P3(W_##name__##_w0, W_##name__##_w1, W_##name__##_b0); \ + VLOG(4) << #name__ "_w0" \ + << " shape: " << W_##name__##_w0->Get().dims(); \ + VLOG(4) << #name__ "_w1" \ + << " shape: " << W_##name__##_w1->Get().dims(); \ + VLOG(4) << #name__ "_b0" \ + << " shape: " << W_##name__##_b0->Get().dims(); \ + auto& W_##name__##_w0_t = W_##name__##_w0->Get(); \ + auto& W_##name__##_w1_t = W_##name__##_w1->Get(); \ + auto& W_##name__##_b0_t = W_##name__##_b0->Get(); GATE_W(forget); GATE_W(input); @@ -255,13 +255,13 @@ void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { attention_fc_w, attention_fc_b, attention_output_w, attention_output_b); auto* lstm_weight = scope.Var(param.LSTMWeight); - auto* lstm_weight_t = lstm_weight->GetMutable(); + auto* lstm_weight_t = lstm_weight->GetMutable(); auto* lstm_bias = scope.Var(param.LSTMBias); - auto* lstm_bias_t = lstm_bias->GetMutable(); + auto* lstm_bias_t = lstm_bias->GetMutable(); // reshape attention_bias auto* attention_bias_t = - scope.FindVar(param.AttentionBias)->GetMutable(); + scope.FindVar(param.AttentionBias)->GetMutable(); PADDLE_ENFORCE_EQ( attention_bias_t->dims().size(), 1, @@ -271,7 +271,7 @@ void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { attention_bias_t->Resize(phi::make_ddim({1, attention_bias_t->dims()[0]})); auto* attention_scalar_bias_t = - scope.FindVar(param.AttentionScalarBias)->GetMutable(); + scope.FindVar(param.AttentionScalarBias)->GetMutable(); attention_scalar_bias_t->Resize( phi::make_ddim({1, attention_scalar_bias_t->dims()[0]})); @@ -289,15 +289,15 @@ void PrepareParameters(Graph* graph, const Param& param, ir::Node* lstm_op) { } // Prepare parameters -void PrepareLSTMWeight(const LoDTensor& W_forget_w0, - const LoDTensor& W_forget_w1, - const LoDTensor& W_input_w0, - const LoDTensor& W_input_w1, - const LoDTensor& W_output_w0, - const LoDTensor& W_output_w1, - const LoDTensor& W_cell_w0, - const LoDTensor& W_cell_w1, - LoDTensor* out) { +void PrepareLSTMWeight(const phi::DenseTensor& W_forget_w0, + const phi::DenseTensor& W_forget_w1, + const phi::DenseTensor& W_input_w0, + const phi::DenseTensor& W_input_w1, + const phi::DenseTensor& W_output_w0, + const phi::DenseTensor& W_output_w1, + const phi::DenseTensor& W_cell_w0, + const phi::DenseTensor& W_cell_w1, + phi::DenseTensor* out) { int D = W_forget_w0.dims()[0]; int M = W_forget_w1.dims()[0]; out->Resize(phi::make_ddim({D + M, 4 * D})); @@ -330,11 +330,11 @@ void PrepareLSTMWeight(const LoDTensor& W_forget_w0, } } -void PrepareLSTMBias(const LoDTensor& B_forget, - const LoDTensor& B_input, - const LoDTensor& B_output, - const LoDTensor& B_cell, - LoDTensor* out) { +void PrepareLSTMBias(const phi::DenseTensor& B_forget, + const phi::DenseTensor& B_input, + const phi::DenseTensor& B_output, + const phi::DenseTensor& B_cell, + phi::DenseTensor* out) { std::array tensors{B_forget.data(), B_input.data(), B_output.data(), diff --git a/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc b/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc index b9915d57a1..0c09ceac99 100644 --- a/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc +++ b/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc @@ -175,10 +175,11 @@ class CoalesceGradTensorPass : public ir::Pass { p_g.second)); pinned_var_set->insert(it->Var()->Name()); } - PADDLE_ENFORCE_EQ(IsLoDTensorType(GetTypeOfVar(vars_info, p_g.second)), - true, - platform::errors::InvalidArgument( - "Parameter@Grad %s is not LoDTensor.", p_g.second)); + PADDLE_ENFORCE_EQ( + IsLoDTensorType(GetTypeOfVar(vars_info, p_g.second)), + true, + platform::errors::InvalidArgument( + "Parameter@Grad %s is not phi::DenseTensor.", p_g.second)); } } diff --git a/paddle/fluid/framework/ir/constant_folding_pass.cc b/paddle/fluid/framework/ir/constant_folding_pass.cc index feba2242ad..31f070de2c 100644 --- a/paddle/fluid/framework/ir/constant_folding_pass.cc +++ b/paddle/fluid/framework/ir/constant_folding_pass.cc @@ -107,15 +107,16 @@ void ConstantFoldingPass::ApplyImpl(ir::Graph *graph) const { if (input_persis) { for (auto in_node : op_node->inputs) { local_scope->Var(in_node->Var()->Name()); - local_scope->FindVar(in_node->Var()->Name())->GetMutable(); + local_scope->FindVar(in_node->Var()->Name()) + ->GetMutable(); // This persistable input node is exclusive, and can be removed if (in_node->outputs.size() == 1L) remove_nodes.emplace(in_node); auto in_shape = in_node->Var()->GetShape(); auto *global_persis_x_tensor = - scope->FindVar(in_node->Name())->GetMutable(); - auto *local_x_tensor = - local_scope->FindVar(in_node->Name())->GetMutable(); + scope->FindVar(in_node->Name())->GetMutable(); + auto *local_x_tensor = local_scope->FindVar(in_node->Name()) + ->GetMutable(); local_x_tensor->Resize(global_persis_x_tensor->dims()); *local_x_tensor = *global_persis_x_tensor; } @@ -124,7 +125,8 @@ void ConstantFoldingPass::ApplyImpl(ir::Graph *graph) const { remove_nodes.emplace(op_node); for (auto out_node : op_node->outputs) { local_scope->Var(out_node->Var()->Name()); - local_scope->FindVar(out_node->Var()->Name())->GetMutable(); + local_scope->FindVar(out_node->Var()->Name()) + ->GetMutable(); // useless out_node can be removed, not need set it persistable ! if (out_node->outputs.size() == 0L) remove_nodes.emplace(out_node); } @@ -135,14 +137,15 @@ void ConstantFoldingPass::ApplyImpl(ir::Graph *graph) const { auto out_desc = out_node->Var(); auto out_name = out_desc->Name(); auto *local_out_tensor = - local_scope->FindVar(out_name)->GetMutable(); + local_scope->FindVar(out_name)->GetMutable(); std::vector out_shape; for (int64_t i = 0; i < local_out_tensor->dims().size(); i++) { out_shape.push_back(local_out_tensor->dims()[i]); } out_desc->SetShape(out_shape); out_desc->SetPersistable(true); - auto *global_out_tensor = scope->Var(out_name)->GetMutable(); + auto *global_out_tensor = + scope->Var(out_name)->GetMutable(); *global_out_tensor = *local_out_tensor; } GraphSafeRemoveNodes(graph, remove_nodes); diff --git a/paddle/fluid/framework/ir/conv_bn_fuse_pass.cc b/paddle/fluid/framework/ir/conv_bn_fuse_pass.cc index 50d2f94275..733bece82a 100644 --- a/paddle/fluid/framework/ir/conv_bn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/conv_bn_fuse_pass.cc @@ -77,12 +77,12 @@ namespace ir { GET_IR_NODE_FROM_SUBGRAPH(bn_saved_variance, bn_saved_variance, pattern_name) void recompute_bias_and_weights(const Scope* scope, - ir::Node* conv_weight, // - const ir::Node& bn_scale, // - const LoDTensor& bn_bias_tensor, // - const ir::Node& bn_mean, // - const ir::Node& bn_variance, // - LoDTensor* eltwise_y_in_tensor, // + ir::Node* conv_weight, // + const ir::Node& bn_scale, // + const phi::DenseTensor& bn_bias_tensor, // + const ir::Node& bn_mean, // + const ir::Node& bn_variance, // + phi::DenseTensor* eltwise_y_in_tensor, // float epsilon, const std::string& conv_type) { using EigenVectorArrayMap = @@ -101,10 +101,12 @@ void recompute_bias_and_weights(const Scope* scope, eltwise_y_in_tensor->dims().size(), bn_bias_tensor.dims().size())); - auto* scale_tensor = scope->FindVar(bn_scale.Name())->GetMutable(); + auto* scale_tensor = + scope->FindVar(bn_scale.Name())->GetMutable(); auto* variance_tensor = - scope->FindVar(bn_variance.Name())->GetMutable(); - auto* mean_tensor = scope->FindVar(bn_mean.Name())->GetMutable(); + scope->FindVar(bn_variance.Name())->GetMutable(); + auto* mean_tensor = + scope->FindVar(bn_mean.Name())->GetMutable(); ConstEigenVectorArrayMap scale_array( scale_tensor->data(), scale_tensor->numel(), 1); @@ -148,7 +150,8 @@ void recompute_bias_and_weights(const Scope* scope, } // Re-compute weight of conv2d from BN - auto* weights = scope->FindVar(conv_weight->Name())->GetMutable(); + auto* weights = + scope->FindVar(conv_weight->Name())->GetMutable(); auto weights_shape = weights->dims(); auto weights_data = weights->mutable_data(platform::CPUPlace()); @@ -308,7 +311,7 @@ void ConvBNFusePass::ApplyImpl(ir::Graph* graph) const { // conv_weight fp32 --> fp16 auto* conv_weight_tensor = - scope->FindVar(conv_weight->Name())->GetMutable(); + scope->FindVar(conv_weight->Name())->GetMutable(); auto tensor_type = conv_weight_tensor->dtype(); if (tensor_type == paddle::experimental::DataType::FLOAT16) { @@ -317,7 +320,7 @@ void ConvBNFusePass::ApplyImpl(ir::Graph* graph) const { // Get batch norm bias auto* bn_bias_tensor = - scope->FindVar(bn_bias->Name())->GetMutable(); + scope->FindVar(bn_bias->Name())->GetMutable(); // Create eltwise_y (conv bias) variable VarDesc eltwise_y_in_desc( @@ -329,7 +332,7 @@ void ConvBNFusePass::ApplyImpl(ir::Graph* graph) const { eltwise_y_in_desc.SetPersistable(true); auto* eltwise_y_in_node = g->CreateVarNode(&eltwise_y_in_desc); auto* eltwise_y_in_tensor = - scope->Var(eltwise_y_in_node->Name())->GetMutable(); + scope->Var(eltwise_y_in_node->Name())->GetMutable(); // Initialize eltwise_y eltwise_y_in_tensor->Resize(bn_bias_tensor->dims()); @@ -370,7 +373,7 @@ void ConvBNFusePass::ApplyImpl(ir::Graph* graph) const { 1UL, platform::errors::InvalidArgument("Find input var Bais error.")); auto* conv_bias_var = scope->FindVar(conv_bias_names[0]); - auto* conv_bias_tensor = conv_bias_var->GetMutable(); + auto* conv_bias_tensor = conv_bias_var->GetMutable(); PADDLE_ENFORCE_EQ( conv_bias_tensor->dims(), eltwise_y_in_tensor->dims(), @@ -580,11 +583,11 @@ void ConvEltwiseAddBNFusePass::ApplyImpl(ir::Graph* graph) const { // Get eltwise_y (conv bias) variable auto* eltwise_y_in_tensor = - scope->FindVar(eltwise_y_in->Name())->GetMutable(); + scope->FindVar(eltwise_y_in->Name())->GetMutable(); // Get batch norm bias auto* bn_bias_tensor = - scope->FindVar(bn_bias->Name())->GetMutable(); + scope->FindVar(bn_bias->Name())->GetMutable(); // update weights and biases float epsilon = @@ -592,7 +595,7 @@ void ConvEltwiseAddBNFusePass::ApplyImpl(ir::Graph* graph) const { // conv_weight fp16 --> fp32 auto* conv_weight_tensor = - scope->FindVar(conv_weight->Name())->GetMutable(); + scope->FindVar(conv_weight->Name())->GetMutable(); auto tensor_type = conv_weight_tensor->dtype(); if (tensor_type == paddle::experimental::DataType::FLOAT16) { @@ -614,7 +617,7 @@ void ConvEltwiseAddBNFusePass::ApplyImpl(ir::Graph* graph) const { eltwise_y_in_desc.SetPersistable(true); auto* eltwise_y_in_node = g->CreateVarNode(&eltwise_y_in_desc); auto* eltwise_y_in_tensor_ex = - scope->Var(eltwise_y_in_node->Name())->GetMutable(); + scope->Var(eltwise_y_in_node->Name())->GetMutable(); // Initialize eltwise_y TensorCopy( diff --git a/paddle/fluid/framework/ir/conv_bn_fuse_pass_tester.cc b/paddle/fluid/framework/ir/conv_bn_fuse_pass_tester.cc index 3e412a52db..324f707af1 100644 --- a/paddle/fluid/framework/ir/conv_bn_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/conv_bn_fuse_pass_tester.cc @@ -30,7 +30,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/cost_model_test.cc b/paddle/fluid/framework/ir/cost_model_test.cc index 86a70d42a7..15e724b0a7 100644 --- a/paddle/fluid/framework/ir/cost_model_test.cc +++ b/paddle/fluid/framework/ir/cost_model_test.cc @@ -49,7 +49,7 @@ class FakeTestOp : public OperatorBase { // Fake RunImpl, for test only Variable *var = scope.FindVar("X"); if (var != nullptr) { - LoDTensor *tensor = var->GetMutable(); + phi::DenseTensor *tensor = var->GetMutable(); tensor->mutable_data(place); } int count = 0; diff --git a/paddle/fluid/framework/ir/delete_fill_constant_op_pass.cc b/paddle/fluid/framework/ir/delete_fill_constant_op_pass.cc index cd5cbf150b..6104de7ab8 100644 --- a/paddle/fluid/framework/ir/delete_fill_constant_op_pass.cc +++ b/paddle/fluid/framework/ir/delete_fill_constant_op_pass.cc @@ -21,7 +21,7 @@ namespace framework { namespace ir { template -void FillConstData(LoDTensor* out_t, T value) { +void FillConstData(phi::DenseTensor* out_t, T value) { auto output_data = out_t->mutable_data(platform::CPUPlace()); for (int i = 0; i < out_t->numel(); i++) { output_data[i] = value; @@ -70,8 +70,8 @@ void DeleteFillConstantOpPass::ApplyImpl(ir::Graph* graph) const { auto fill_constant_out_desc = fill_constant_out_node->Var(); fill_constant_out_desc->SetShape(shape); fill_constant_out_desc->SetPersistable(true); - auto* fill_constant_out_tensor = - scope->Var(fill_constant_out_desc->Name())->GetMutable(); + auto* fill_constant_out_tensor = scope->Var(fill_constant_out_desc->Name()) + ->GetMutable(); auto dtype = framework::TransToPhiDataType(fill_constant_out_desc->GetDataType()); fill_constant_out_tensor->Resize(phi::make_ddim(shape)); diff --git a/paddle/fluid/framework/ir/delete_quant_dequant_filter_op_pass.cc b/paddle/fluid/framework/ir/delete_quant_dequant_filter_op_pass.cc index 2f95f476db..6d22db0292 100644 --- a/paddle/fluid/framework/ir/delete_quant_dequant_filter_op_pass.cc +++ b/paddle/fluid/framework/ir/delete_quant_dequant_filter_op_pass.cc @@ -123,8 +123,8 @@ void DeleteQuantDequantFilterOpPass::ApplyImpl(ir::Graph* graph) const { auto dequant_type = quant_dequant_op->Op()->Type(); // get weight tensor - auto* weight_tensor = - scope->GetVar(quant_dequant_op_x->Name())->GetMutable(); + auto* weight_tensor = scope->GetVar(quant_dequant_op_x->Name()) + ->GetMutable(); auto w_dims = weight_tensor->dims(); float* quantized_weight_data = @@ -148,8 +148,8 @@ void DeleteQuantDequantFilterOpPass::ApplyImpl(ir::Graph* graph) const { "Scales size in channel-wise quant dequantize op " "should be 1, got %d.", scales_name.size())); - const LoDTensor& channel_scale_tensor = - scope->FindVar(scales_name[0])->Get(); + const phi::DenseTensor& channel_scale_tensor = + scope->FindVar(scales_name[0])->Get(); PADDLE_ENFORCE( paddle::platform::is_cpu_place(channel_scale_tensor.place()), platform::errors::InvalidArgument( diff --git a/paddle/fluid/framework/ir/delete_quant_dequant_linear_op_pass.cc b/paddle/fluid/framework/ir/delete_quant_dequant_linear_op_pass.cc index e049d1e950..9057f34504 100644 --- a/paddle/fluid/framework/ir/delete_quant_dequant_linear_op_pass.cc +++ b/paddle/fluid/framework/ir/delete_quant_dequant_linear_op_pass.cc @@ -113,8 +113,9 @@ void DeleteQuantDequantLinearOpPass::ApplyImpl(ir::Graph* graph) const { std::unordered_set nodes2rm = {}; // Get input scale from tensor - const LoDTensor& input_scale_tensor = - scope->GetVar(quantize_linear_op_scale->Name())->Get(); + const phi::DenseTensor& input_scale_tensor = + scope->GetVar(quantize_linear_op_scale->Name()) + ->Get(); PADDLE_ENFORCE_EQ( paddle::platform::is_cpu_place(input_scale_tensor.place()), true, diff --git a/paddle/fluid/framework/ir/delete_quant_dequant_op_pass.cc b/paddle/fluid/framework/ir/delete_quant_dequant_op_pass.cc index bae23b3cd6..ebb0ed9d00 100644 --- a/paddle/fluid/framework/ir/delete_quant_dequant_op_pass.cc +++ b/paddle/fluid/framework/ir/delete_quant_dequant_op_pass.cc @@ -70,8 +70,8 @@ void DeleteQuantDequantOpPass::ApplyImpl(ir::Graph* graph) const { scope, platform::errors::InvalidArgument( "Scope in DeleteQuantDequantOpPass should not be null.")); - const LoDTensor& input_scale_tensor = - scope->FindVar(input_scale_var_name)->Get(); + const phi::DenseTensor& input_scale_tensor = + scope->FindVar(input_scale_var_name)->Get(); PADDLE_ENFORCE_EQ( paddle::platform::is_cpu_place(input_scale_tensor.place()), true, diff --git a/paddle/fluid/framework/ir/delete_weight_dequant_linear_op_pass.cc b/paddle/fluid/framework/ir/delete_weight_dequant_linear_op_pass.cc index ccd9cbce7b..cc9ce6d0b2 100644 --- a/paddle/fluid/framework/ir/delete_weight_dequant_linear_op_pass.cc +++ b/paddle/fluid/framework/ir/delete_weight_dequant_linear_op_pass.cc @@ -305,7 +305,7 @@ void DeleteWeightQuantDequantLinearOpPass::ApplyImpl(ir::Graph* graph) const { // get weight tensor auto* weight_tensor = scope->GetVar(weight_dequantize_linear_op_x->Name()) - ->GetMutable(); + ->GetMutable(); int8_t* quantized_weight_data = weight_tensor->mutable_data(platform::CPUPlace()); auto w_dims = weight_tensor->dims(); @@ -314,7 +314,7 @@ void DeleteWeightQuantDequantLinearOpPass::ApplyImpl(ir::Graph* graph) const { std::vector weight_scale; auto* weight_scale_tensor = scope->GetVar(weight_dequantize_linear_op_scale->Name()) - ->GetMutable(); + ->GetMutable(); float* weight_scale_data = weight_scale_tensor->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/dense_fc_to_sparse_pass_tester.cc b/paddle/fluid/framework/ir/dense_fc_to_sparse_pass_tester.cc index 6490c83e9e..6151778a58 100644 --- a/paddle/fluid/framework/ir/dense_fc_to_sparse_pass_tester.cc +++ b/paddle/fluid/framework/ir/dense_fc_to_sparse_pass_tester.cc @@ -25,7 +25,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/dense_multihead_matmul_to_sparse_pass_tester.cc b/paddle/fluid/framework/ir/dense_multihead_matmul_to_sparse_pass_tester.cc index 1dfa33eaad..a8975a08d6 100644 --- a/paddle/fluid/framework/ir/dense_multihead_matmul_to_sparse_pass_tester.cc +++ b/paddle/fluid/framework/ir/dense_multihead_matmul_to_sparse_pass_tester.cc @@ -23,7 +23,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fc_fuse_pass.cc b/paddle/fluid/framework/ir/fc_fuse_pass.cc index c2a2eefd86..cbbac28144 100644 --- a/paddle/fluid/framework/ir/fc_fuse_pass.cc +++ b/paddle/fluid/framework/ir/fc_fuse_pass.cc @@ -195,7 +195,7 @@ int FCFusePass::ApplyFCPattern(Graph* graph, bool with_relu) const { auto* w_node = g->CreateVarNode(&w_key); if (!use_gpu && use_fc_padding) { auto* scope = param_scope(); - auto* weight = scope->FindVar(w->Name())->GetMutable(); + auto* weight = scope->FindVar(w->Name())->GetMutable(); auto* weight_data = weight->data(); auto weight_dims = weight->dims(); int weight_num = product(weight_dims); diff --git a/paddle/fluid/framework/ir/fc_fuse_pass_tester.cc b/paddle/fluid/framework/ir/fc_fuse_pass_tester.cc index 74fe009210..b1850cb997 100644 --- a/paddle/fluid/framework/ir/fc_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/fc_fuse_pass_tester.cc @@ -24,7 +24,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fc_gru_fuse_pass.cc b/paddle/fluid/framework/ir/fc_gru_fuse_pass.cc index 72bdd53cba..5f05b41bdc 100644 --- a/paddle/fluid/framework/ir/fc_gru_fuse_pass.cc +++ b/paddle/fluid/framework/ir/fc_gru_fuse_pass.cc @@ -228,8 +228,8 @@ int FCGRUFusePass::BuildFusion(Graph* graph, nullptr, platform::errors::NotFound("FC bias var has not been found.")); - auto* gru_bias_tensor = gru_bias_var->GetMutable(); - auto* fc_bias_tensor = fc_bias_var->GetMutable(); + auto* gru_bias_tensor = gru_bias_var->GetMutable(); + auto* fc_bias_tensor = fc_bias_var->GetMutable(); PADDLE_ENFORCE_EQ( gru_bias_tensor->numel(), fc_bias_tensor->numel(), diff --git a/paddle/fluid/framework/ir/fc_gru_fuse_pass_tester.h b/paddle/fluid/framework/ir/fc_gru_fuse_pass_tester.h index c85d1e959a..5c49a73ac6 100644 --- a/paddle/fluid/framework/ir/fc_gru_fuse_pass_tester.h +++ b/paddle/fluid/framework/ir/fc_gru_fuse_pass_tester.h @@ -26,7 +26,7 @@ namespace fc_gru_test { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fc_lstm_fuse_pass_tester.h b/paddle/fluid/framework/ir/fc_lstm_fuse_pass_tester.h index 07c1ab7087..0d85539f62 100644 --- a/paddle/fluid/framework/ir/fc_lstm_fuse_pass_tester.h +++ b/paddle/fluid/framework/ir/fc_lstm_fuse_pass_tester.h @@ -28,7 +28,7 @@ namespace fc_lstm_test { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_optimizer_op_pass.cc b/paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_optimizer_op_pass.cc index cdb8b7d69a..35f6544a32 100644 --- a/paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_optimizer_op_pass.cc +++ b/paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_optimizer_op_pass.cc @@ -392,13 +392,13 @@ void FuseOptimizerOpPass::FuseGradientsToContinuousSpace( iter->second.front()->Var(), platform::errors::InvalidArgument("The gradient var(%s) node is null.", grad_var_name)); - PADDLE_ENFORCE_EQ( - IsLoDTensorType(iter->second.front()->Var()->GetType()), - true, - platform::errors::InvalidArgument( - "Currently the gradient(%s) type only should be LoDTensor when " - "fusing optimizer ops.", - grad_var_name)); + PADDLE_ENFORCE_EQ(IsLoDTensorType(iter->second.front()->Var()->GetType()), + true, + platform::errors::InvalidArgument( + "Currently the gradient(%s) type only should be " + "phi::DenseTensor when " + "fusing optimizer ops.", + grad_var_name)); for (auto var : iter->second) { pinned_var_set.insert(var->Var()->Name()); } diff --git a/paddle/fluid/framework/ir/fused_multi_transformer_decoder_pass_tester.cc b/paddle/fluid/framework/ir/fused_multi_transformer_decoder_pass_tester.cc index 100f2ad8da..edf00ae17c 100644 --- a/paddle/fluid/framework/ir/fused_multi_transformer_decoder_pass_tester.cc +++ b/paddle/fluid/framework/ir/fused_multi_transformer_decoder_pass_tester.cc @@ -22,7 +22,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass.cc b/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass.cc index 3f163fc368..d93c297656 100644 --- a/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass.cc +++ b/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass.cc @@ -1100,12 +1100,12 @@ PDNode* MultiDevicesFusedMultiTransformerEncoderFuseQKVPattern::operator()() { } // namespace patterns template -inline void QKVWeightsProcess(framework::LoDTensor* wq_tensor, - framework::LoDTensor* wk_tensor, - framework::LoDTensor* wv_tensor, - framework::LoDTensor* bq_tensor, - framework::LoDTensor* bk_tensor, - framework::LoDTensor* bv_tensor, +inline void QKVWeightsProcess(phi::DenseTensor* wq_tensor, + phi::DenseTensor* wk_tensor, + phi::DenseTensor* wv_tensor, + phi::DenseTensor* bq_tensor, + phi::DenseTensor* bk_tensor, + phi::DenseTensor* bv_tensor, const int num_head, const int dim_head, const int dim_embed) { @@ -1119,7 +1119,7 @@ inline void QKVWeightsProcess(framework::LoDTensor* wq_tensor, auto combined_w_dims = phi::make_ddim({3, num_head, dim_head, dim_embed}); auto combined_bias_dims = phi::make_ddim({3, num_head, dim_head}); - framework::LoDTensor tmp_combined_w_tensor; + phi::DenseTensor tmp_combined_w_tensor; tmp_combined_w_tensor.Resize(combined_w_dims); auto* tmp_combined_w_data = tmp_combined_w_tensor.mutable_data(platform::CPUPlace()); @@ -1144,7 +1144,7 @@ inline void QKVWeightsProcess(framework::LoDTensor* wq_tensor, memcpy( new_combined_w_data, tmp_combined_w_data, sizeof(T) * wq_tensor->numel()); - framework::LoDTensor tmp_combined_bias_tensor; + phi::DenseTensor tmp_combined_bias_tensor; tmp_combined_bias_tensor.Resize(combined_bias_dims); auto* tmp_combined_bias_data = tmp_combined_bias_tensor.mutable_data(platform::CPUPlace()); @@ -1164,15 +1164,15 @@ inline void QKVWeightsProcess(framework::LoDTensor* wq_tensor, } template -inline void QKVWeightsProcessFuseQKV(framework::LoDTensor* qkv_w_tensor, - framework::LoDTensor* qkv_b_tensor, +inline void QKVWeightsProcessFuseQKV(phi::DenseTensor* qkv_w_tensor, + phi::DenseTensor* qkv_b_tensor, const int num_head, const int dim_head, const int dim_embed) { auto* qkv_w_data = qkv_w_tensor->mutable_data(platform::CPUPlace()); auto transpose_w_dims = phi::make_ddim({3, num_head, dim_head, dim_embed}); - framework::LoDTensor tmp_transpose_w_tensor; + phi::DenseTensor tmp_transpose_w_tensor; tmp_transpose_w_tensor.Resize(transpose_w_dims); auto* tmp_transpose_w_data = tmp_transpose_w_tensor.mutable_data(platform::CPUPlace()); @@ -1202,7 +1202,7 @@ inline void QKVWeightsProcessFuseQKV(framework::LoDTensor* qkv_w_tensor, auto* qkv_b_data = qkv_b_tensor->mutable_data(platform::CPUPlace()); auto transpose_b_dims = phi::make_ddim({3, num_head, dim_head}); - framework::LoDTensor tmp_transpose_b_tensor; + phi::DenseTensor tmp_transpose_b_tensor; tmp_transpose_b_tensor.Resize(transpose_b_dims); auto* tmp_transpose_b_data = tmp_transpose_b_tensor.mutable_data(platform::CPUPlace()); @@ -1289,18 +1289,18 @@ int FusedMultiTransformerEncoderPass::BuildFusion(Graph* graph, int layer_idx = atoi(ln_idx_str.c_str()) / 2; auto* wq_tensor = - scope->FindVar(matmul0_w->Name())->GetMutable(); + scope->FindVar(matmul0_w->Name())->GetMutable(); auto* wk_tensor = - scope->FindVar(matmul1_w->Name())->GetMutable(); + scope->FindVar(matmul1_w->Name())->GetMutable(); auto* wv_tensor = - scope->FindVar(matmul2_w->Name())->GetMutable(); + scope->FindVar(matmul2_w->Name())->GetMutable(); auto* bq_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); auto* bk_tensor = - scope->FindVar(eltadd1_b->Name())->GetMutable(); + scope->FindVar(eltadd1_b->Name())->GetMutable(); auto* bv_tensor = - scope->FindVar(eltadd2_b->Name())->GetMutable(); + scope->FindVar(eltadd2_b->Name())->GetMutable(); if (wq_tensor->dtype() == phi::DataType::FLOAT32) { QKVWeightsProcess(wq_tensor, @@ -2053,9 +2053,9 @@ int FusedMultiTransformerEncoderFuseQKVPass::BuildFusion( int layer_idx = atoi(ln_idx_str.c_str()) / 2; auto* qkv_w_tensor = - scope->FindVar(matmul0_w->Name())->GetMutable(); + scope->FindVar(matmul0_w->Name())->GetMutable(); auto* qkv_b_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); if (qkv_w_tensor->dtype() == phi::DataType::FLOAT32) { QKVWeightsProcessFuseQKV( @@ -2736,9 +2736,9 @@ int MultiDevicesFusedMultiTransformerEncoderFuseQKVPass::BuildFusion( int layer_idx = atoi(ln_idx_str.c_str()) / 2; auto* qkv_w_tensor = - scope->FindVar(matmul0_w->Name())->GetMutable(); + scope->FindVar(matmul0_w->Name())->GetMutable(); auto* qkv_b_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); int dim_embed = qkv_w_tensor->dims()[0]; diff --git a/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass_tester.cc b/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass_tester.cc index 61017b273a..b23f8dcac7 100644 --- a/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass_tester.cc +++ b/paddle/fluid/framework/ir/fused_multi_transformer_encoder_pass_tester.cc @@ -22,7 +22,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/fusion_group/code_generator_tester.cc b/paddle/fluid/framework/ir/fusion_group/code_generator_tester.cc index 49bac0378b..762922ba88 100644 --- a/paddle/fluid/framework/ir/fusion_group/code_generator_tester.cc +++ b/paddle/fluid/framework/ir/fusion_group/code_generator_tester.cc @@ -89,7 +89,7 @@ inline float elementwise_mul_grad_dy(float x, float y, float out, float dout) { } void CheckOutput(const std::vector& expressions, - const std::vector cpu_tensors, + const std::vector cpu_tensors, const std::vector input_ids_of_subgraph, const std::vector output_ids_of_subgraph, int i, @@ -152,7 +152,7 @@ void CheckOutput(const std::vector& expressions, } template -void SetupRandomCPUTensor(LoDTensor* tensor) { +void SetupRandomCPUTensor(phi::DenseTensor* tensor) { static unsigned int seed = 100; std::mt19937 rng(seed++); std::uniform_real_distribution uniform_dist(0, 1); diff --git a/paddle/fluid/framework/ir/layer_norm_fuse_pass.cc b/paddle/fluid/framework/ir/layer_norm_fuse_pass.cc index 260fcda378..5a65ba86b6 100644 --- a/paddle/fluid/framework/ir/layer_norm_fuse_pass.cc +++ b/paddle/fluid/framework/ir/layer_norm_fuse_pass.cc @@ -267,7 +267,8 @@ void LayerNormFusePass::ApplyImpl(Graph* graph) const { GET_IR_NODE_FROM_SUBGRAPH(shift, shift, layer_norm_pattern); GET_IR_NODE_FROM_SUBGRAPH(shift_out, shift_out, layer_norm_pattern); - auto* eps_tensor = scope->FindVar(eps->Name())->GetMutable(); + auto* eps_tensor = + scope->FindVar(eps->Name())->GetMutable(); const auto& x_shape = x->Var()->GetShape(); // ------------------ subgraph node's validation --------------------------- @@ -336,7 +337,8 @@ void LayerNormFusePass::ApplyImpl(Graph* graph) const { // gamma/beta must be a 1-dimensional tensor of size on layer_norm auto layer_norm_x_mat_dims = phi::flatten_to_2d(phi::make_ddim(x_shape), begin_norm_axis); - auto* gamma_tensor = scope->FindVar(gamma->Name())->GetMutable(); + auto* gamma_tensor = + scope->FindVar(gamma->Name())->GetMutable(); VarDesc new_gamma_desc(patterns::PDNodeName("layer_norm_fuse", "Scale")); new_gamma_desc.SetShape({layer_norm_x_mat_dims[1]}); new_gamma_desc.SetDataType( @@ -345,13 +347,14 @@ void LayerNormFusePass::ApplyImpl(Graph* graph) const { new_gamma_desc.SetPersistable(true); auto* new_gamma_node = g->CreateVarNode(&new_gamma_desc); auto* new_gamma_tensor = - scope->Var(new_gamma_node->Name())->GetMutable(); + scope->Var(new_gamma_node->Name())->GetMutable(); new_gamma_tensor->Resize(phi::make_ddim({layer_norm_x_mat_dims[1]})); memcpy(new_gamma_tensor->mutable_data(platform::CPUPlace()), gamma_tensor->mutable_data(platform::CPUPlace()), layer_norm_x_mat_dims[1] * sizeof(float)); - auto* beta_tensor = scope->FindVar(beta->Name())->GetMutable(); + auto* beta_tensor = + scope->FindVar(beta->Name())->GetMutable(); VarDesc new_beta_desc(patterns::PDNodeName("layer_norm_fuse", "Bias")); new_beta_desc.SetShape({layer_norm_x_mat_dims[1]}); new_beta_desc.SetDataType( @@ -360,7 +363,7 @@ void LayerNormFusePass::ApplyImpl(Graph* graph) const { new_beta_desc.SetPersistable(true); auto* new_beta_node = g->CreateVarNode(&new_beta_desc); auto* new_beta_tensor = - scope->Var(new_beta_node->Name())->GetMutable(); + scope->Var(new_beta_node->Name())->GetMutable(); new_beta_tensor->Resize(phi::make_ddim({layer_norm_x_mat_dims[1]})); memcpy(new_beta_tensor->mutable_data(platform::CPUPlace()), diff --git a/paddle/fluid/framework/ir/matmul_scale_fuse_pass.cc b/paddle/fluid/framework/ir/matmul_scale_fuse_pass.cc index 08adec160f..64c74ab0f9 100644 --- a/paddle/fluid/framework/ir/matmul_scale_fuse_pass.cc +++ b/paddle/fluid/framework/ir/matmul_scale_fuse_pass.cc @@ -149,7 +149,7 @@ void MatmulScaleFusePass::ApplyImpl(ir::Graph* graph) const { auto* scale_var = scope->FindVar(scale_var_name); // ScaleTensor must be weight if (scale_var == nullptr) return; - auto* scale_tensor = scale_var->GetMutable(); + auto* scale_tensor = scale_var->GetMutable(); scale = *(scale_tensor->data()); } @@ -211,12 +211,12 @@ void MatmulV2ScaleFusePass::ApplyImpl(ir::Graph* graph) const { auto* scale_var = scope->FindVar(scale_var_name); // ScaleTensor must be weight if (scale_var == nullptr) return; - auto* scale_tensor = scale_var->GetMutable(); + auto* scale_tensor = scale_var->GetMutable(); scale = *(scale_tensor->data()); } auto* matmul_y = - scope->FindVar(matmul_v2_in_y->Name())->GetMutable(); + scope->FindVar(matmul_v2_in_y->Name())->GetMutable(); auto y_data = matmul_y->mutable_data(platform::CPUPlace()); for (int i = 0; i < matmul_y->numel(); ++i) { y_data[i] *= scale; diff --git a/paddle/fluid/framework/ir/memory_optimize_pass/eager_deletion_pass.cc b/paddle/fluid/framework/ir/memory_optimize_pass/eager_deletion_pass.cc index 84b28e696e..ef0f6dde3d 100644 --- a/paddle/fluid/framework/ir/memory_optimize_pass/eager_deletion_pass.cc +++ b/paddle/fluid/framework/ir/memory_optimize_pass/eager_deletion_pass.cc @@ -47,12 +47,12 @@ static std::map> VarsGroupByScopeIdx( return result; } -// Check whether the variable is LoDTensor based on static VarDesc info +// Check whether the variable is phi::DenseTensor based on static VarDesc info static bool IsLoDTensor(VarDesc *var) { return var->Proto()->type().type() == proto::VarType::LOD_TENSOR; } -// Get memory size of LoDTensor +// Get memory size of phi::DenseTensor static int64_t GetMemorySize( const std::unordered_map> &vars, @@ -64,7 +64,7 @@ static int64_t GetMemorySize( PADDLE_ENFORCE_EQ(IsLoDTensor(var_desc), true, platform::errors::InvalidArgument( - "Var(%s) must be LoDTensor.", var_name)); + "Var(%s) must be phi::DenseTensor.", var_name)); auto dims = var_desc->GetShape(); return SizeOfType(var_desc->GetDataType()) * std::accumulate(dims.begin(), @@ -73,10 +73,10 @@ static int64_t GetMemorySize( std::multiplies()); } -// Split all variables in the graph into LoDTensor and Non-LoDTensor (e.g. -// SelectedRows, LoDTensorArray) -// Since partial GC is based on static analysis of memory size of each variable -// So we should skip SelectedRows and LoDTensorArray here +// Split all variables in the graph into phi::DenseTensor and +// Non-phi::DenseTensor (e.g. SelectedRows, LoDTensorArray) Since partial GC is +// based on static analysis of memory size of each variable So we should skip +// SelectedRows and LoDTensorArray here static void SplitIntoLoDTensorAndNonLoDTensorVars( const OpToVarNameSetMap &m, const details::GraphVars &vars, @@ -128,7 +128,7 @@ static OpToVarNameSetMap ShrinkGCVars( if (fraction_of_memory_size <= 0.0) return {}; /** - * Step 1: Split all variables into LoDTensor and Non-LoDTensor. + * Step 1: Split all variables into phi::DenseTensor and Non-phi::DenseTensor. * We can only calculate memory size of LoDTensors */ OpToVarNameSetMap lod_tensors, other_vars; diff --git a/paddle/fluid/framework/ir/memory_optimize_pass/memory_reuse_pass.cc b/paddle/fluid/framework/ir/memory_optimize_pass/memory_reuse_pass.cc index f3f69c094f..520ab133b4 100644 --- a/paddle/fluid/framework/ir/memory_optimize_pass/memory_reuse_pass.cc +++ b/paddle/fluid/framework/ir/memory_optimize_pass/memory_reuse_pass.cc @@ -208,7 +208,7 @@ MemoryReusePass::InsertShareTensorBufferOpHandleToGraph( * - it has not been reused. If an input var is reused twice or more, * the calculation result may be wrong. * - it is not a persistable var. - * - it is LoDTensor. We can support SelectedRows in the future. + * - it is phi::DenseTensor. We can support SelectedRows in the future. */ bool MemoryReusePass::IsInVarReusable(const details::VarHandle &in_var) const { if (in_var.Name() == kEmptyVarName) { @@ -242,7 +242,7 @@ bool MemoryReusePass::IsInVarReusable(const details::VarHandle &in_var) const { * - it has not reused other var's memory. It is not necessary to do memory * reuse twice for the same var. * - it is not a persistable var. - * - it is LoDTensor. We can support SelectedRows in the future. + * - it is phi::DenseTensor. We can support SelectedRows in the future. * - it does not occur in inputs of the generated op. It would happen when * op has the same var as both input and output. */ diff --git a/paddle/fluid/framework/ir/mkldnn/compute_propagate_scales_mkldnn_pass.cc b/paddle/fluid/framework/ir/mkldnn/compute_propagate_scales_mkldnn_pass.cc index c416ebf200..95a2fdee31 100755 --- a/paddle/fluid/framework/ir/mkldnn/compute_propagate_scales_mkldnn_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/compute_propagate_scales_mkldnn_pass.cc @@ -112,7 +112,7 @@ void ComputePropagateScalesMkldnnPass::ComputeVarScales( "The input persistable var [%s] of [%s] op is not found.", var_name, op_desc->Type())); - auto* weight_tensor = var->GetMutable(); + auto* weight_tensor = var->GetMutable(); const auto dims = weight_tensor->dims(); int volume = 1; for (int i = 1; i < dims.size(); i++) { @@ -153,8 +153,8 @@ void ComputePropagateScalesMkldnnPass::ComputeSingleGruWeightScales( platform::errors::NotFound("The input persistable var [%s] is not found.", wh_var_name)); - const auto* wx_tensor = wx_var->GetMutable(); - const auto* wh_tensor = wh_var->GetMutable(); + const auto* wx_tensor = wx_var->GetMutable(); + const auto* wh_tensor = wh_var->GetMutable(); const int OC = wh_tensor->dims()[0]; std::vector scale_ur(2 * OC); std::vector scale_o(OC); @@ -252,8 +252,8 @@ void ComputePropagateScalesMkldnnPass::ComputeSingleLstmWeightScales( platform::errors::NotFound("The input persistable var [%s] is not found.", wh_var_name)); - const auto* wx_tensor = wx_var->GetMutable(); - const auto* wh_tensor = wh_var->GetMutable(); + const auto* wx_tensor = wx_var->GetMutable(); + const auto* wh_tensor = wh_var->GetMutable(); std::vector scale(wx_tensor->dims()[1]); for (int row_id = 0; row_id < wx_tensor->dims()[0]; row_id++) { diff --git a/paddle/fluid/framework/ir/mkldnn/conv_affine_channel_mkldnn_fuse_pass.cc b/paddle/fluid/framework/ir/mkldnn/conv_affine_channel_mkldnn_fuse_pass.cc index 814d1d5d73..5bf025af11 100644 --- a/paddle/fluid/framework/ir/mkldnn/conv_affine_channel_mkldnn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/conv_affine_channel_mkldnn_fuse_pass.cc @@ -52,8 +52,8 @@ class Node; void recompute_bias_and_weights(const Scope* scope, ir::Node* conv_weight, const ir::Node& ac_scale, - const LoDTensor& ac_bias_tensor, - LoDTensor* eltwise_y_in_tensor) { + const phi::DenseTensor& ac_bias_tensor, + phi::DenseTensor* eltwise_y_in_tensor) { using EigenVectorArrayMap = Eigen::Map>; using ConstEigenVectorArrayMap = @@ -71,7 +71,8 @@ void recompute_bias_and_weights(const Scope* scope, eltwise_y_in_tensor->dims().size(), ac_bias_tensor.dims().size())); - auto* scale_tensor = scope->FindVar(ac_scale.Name())->GetMutable(); + auto* scale_tensor = + scope->FindVar(ac_scale.Name())->GetMutable(); ConstEigenVectorArrayMap scale_array( scale_tensor->data(), scale_tensor->numel(), 1); @@ -86,7 +87,8 @@ void recompute_bias_and_weights(const Scope* scope, eltwise_y_in_array = (eltwise_y_in_array * scale_array) + ac_bias_array; // Re-compute weight of conv2d from AffineChannel - auto* weights = scope->FindVar(conv_weight->Name())->GetMutable(); + auto* weights = + scope->FindVar(conv_weight->Name())->GetMutable(); auto weights_shape = weights->dims(); auto weights_shape_2d = phi::flatten_to_2d(weights_shape, 1); auto* weights_data = weights->mutable_data(platform::CPUPlace()); @@ -214,7 +216,7 @@ void ConvAffineChannelFusePass::ApplyImpl(ir::Graph* graph) const { // Get affine_channel bias for resizing eltwise_y! auto* ac_bias_tensor = - scope->FindVar(ac_bias->Name())->GetMutable(); + scope->FindVar(ac_bias->Name())->GetMutable(); // Create eltwise_y (conv bias) variable VarDesc eltwise_y_in_desc( @@ -229,7 +231,7 @@ void ConvAffineChannelFusePass::ApplyImpl(ir::Graph* graph) const { // Initialize eltwise_y auto* eltwise_y_in_node = g->CreateVarNode(&eltwise_y_in_desc); auto* eltwise_y_in_tensor = - scope->Var(eltwise_y_in_node->Name())->GetMutable(); + scope->Var(eltwise_y_in_node->Name())->GetMutable(); eltwise_y_in_tensor->Resize(ac_bias_tensor->dims()); std::fill_n(eltwise_y_in_tensor->mutable_data(platform::CPUPlace()), eltwise_y_in_tensor->numel(), diff --git a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc index 27b69d1cd2..24bbcbca01 100644 --- a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc @@ -180,9 +180,9 @@ Conv3DBiasFusePass::Conv3DBiasFusePass() { } template -LoDTensor tensor_apply_eltwise(const LoDTensor& vec_a, - const LoDTensor& vec_b, - BinaryOperation f) { +phi::DenseTensor tensor_apply_eltwise(const phi::DenseTensor& vec_a, + const phi::DenseTensor& vec_b, + BinaryOperation f) { PADDLE_ENFORCE_EQ(vec_a.dims(), vec_b.dims(), platform::errors::InvalidArgument( @@ -190,7 +190,7 @@ LoDTensor tensor_apply_eltwise(const LoDTensor& vec_a, "different: %s, %s.", vec_a.dims(), vec_b.dims())); - LoDTensor vec_y; + phi::DenseTensor vec_y; vec_y.Resize(vec_a.dims()); const float* a = vec_a.data(); const float* b = vec_b.data(); @@ -253,7 +253,7 @@ void ConvBiasFusePass::ApplyImpl(ir::Graph* graph) const { } auto* eltwise_bias_tensor = - scope->FindVar(eltwise_bias->Name())->GetMutable(); + scope->FindVar(eltwise_bias->Name())->GetMutable(); auto input_names = conv->Op()->InputNames(); bool has_bias = std::find(input_names.begin(), input_names.end(), "Bias") != @@ -266,7 +266,7 @@ void ConvBiasFusePass::ApplyImpl(ir::Graph* graph) const { 1, platform::errors::NotFound("Can not find var Bias.")); auto* conv_bias_var = scope->FindVar(conv_bias_names[0]); - auto* conv_bias_tensor = conv_bias_var->GetMutable(); + auto* conv_bias_tensor = conv_bias_var->GetMutable(); PADDLE_ENFORCE_EQ( conv_bias_tensor->dims(), eltwise_bias_tensor->dims(), diff --git a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc index aefdd63cfc..41aea6218b 100644 --- a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc @@ -104,7 +104,7 @@ void InitTensorHolder(Scope* scope, const paddle::platform::Place& place, const char* var_name) { auto x = scope->Var(var_name); - auto tensor = x->GetMutable(); + auto tensor = x->GetMutable(); tensor->mutable_data( place, framework::TransToPhiDataType(proto::VarType::FP32), 1); } diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc index 3161eeeb4b..80aa81b9b0 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc @@ -289,7 +289,7 @@ bool CPUQuantizePass::AreScalesPresentForNodes( return present; } -std::pair CPUQuantizePass::GetScaleDataByName( +std::pair CPUQuantizePass::GetScaleDataByName( const std::string& name) const { if (var_quant_scales_->empty()) { auto& scales = Get("quant_var_scales"); @@ -298,16 +298,18 @@ std::pair CPUQuantizePass::GetScaleDataByName( return var_quant_scales_->at(name); } -std::pair CPUQuantizePass::GetScaleDataForNode( +std::pair CPUQuantizePass::GetScaleDataForNode( const Node* node) const { return GetScaleDataByName(node->Name()); } -LoDTensor CPUQuantizePass::GetScaleTensorByName(const std::string& name) const { +phi::DenseTensor CPUQuantizePass::GetScaleTensorByName( + const std::string& name) const { return GetScaleDataByName(name).second; } -LoDTensor CPUQuantizePass::GetScaleTensorForNode(const Node* node) const { +phi::DenseTensor CPUQuantizePass::GetScaleTensorForNode( + const Node* node) const { return GetScaleDataForNode(node).second; } @@ -1071,7 +1073,7 @@ void CPUQuantizePass::QuantizeMultiGru(Graph* graph) const { auto* w_scale_node = g->CreateVarNode(&scale_var_desc); auto* w_scale_tensor_dst = - scope->Var(w_scale_node->Name())->GetMutable(); + scope->Var(w_scale_node->Name())->GetMutable(); w_scale_tensor_dst->Resize(scale_tensor_src.dims()); auto* dst_data = w_scale_tensor_dst->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.h b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.h index ded113dfdc..522b57eb13 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.h +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.h @@ -37,7 +37,7 @@ class Graph; class Node; using VarQuantScale = - std::unordered_map>; + std::unordered_map>; /* * Quantize all supported operators. @@ -93,10 +93,11 @@ class CPUQuantizePass : public FusePassBase { bool AreScalesPresentForVarNames(std::vector names) const; bool AreScalesPresentForNodes(std::initializer_list nodes) const; - std::pair GetScaleDataByName(const std::string& name) const; - std::pair GetScaleDataForNode(const Node* node) const; - LoDTensor GetScaleTensorByName(const std::string& name) const; - LoDTensor GetScaleTensorForNode(const Node* node) const; + std::pair GetScaleDataByName( + const std::string& name) const; + std::pair GetScaleDataForNode(const Node* node) const; + phi::DenseTensor GetScaleTensorByName(const std::string& name) const; + phi::DenseTensor GetScaleTensorForNode(const Node* node) const; double GetScaleValueByName(const std::string& name, bool* is_unsigned = nullptr) const; double GetScaleValueForNode(const Node* node, diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc index 7062321450..201c2be160 100755 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc @@ -131,7 +131,7 @@ void InitTensorHolder(Scope* scope, const paddle::platform::Place& place, const char* var_name) { auto x = scope->Var(var_name); - auto tensor = x->GetMutable(); + auto tensor = x->GetMutable(); tensor->mutable_data( place, framework::TransToPhiDataType(proto::VarType::FP32), 1); } @@ -151,7 +151,7 @@ void PreparePass(std::unique_ptr* graph, for (auto& v : variable_names) { if (v.compare(var_without_scale) == 0) continue; InitTensorHolder(&scope, place, v.c_str()); - LoDTensor tensor; + phi::DenseTensor tensor; tensor.Resize({1}); auto* ptr = tensor.mutable_data(place); ptr[0] = SCALE; diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_squash_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_squash_pass_tester.cc index cd71ff153d..11f6098819 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_squash_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_squash_pass_tester.cc @@ -716,7 +716,7 @@ void InitTensorHolder(Scope* scope, const paddle::platform::Place& place, const char* var_name) { auto x = scope->Var(var_name); - auto tensor = x->GetMutable(); + auto tensor = x->GetMutable(); tensor->mutable_data( place, framework::TransToPhiDataType(proto::VarType::FP32), 1); } diff --git a/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass.cc b/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass.cc index b1a0aaa830..e2000708b8 100644 --- a/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass.cc @@ -25,7 +25,8 @@ namespace ir { namespace { template -void QuantizeParams(LoDTensor* param_tensor, const std::vector& scales) { +void QuantizeParams(phi::DenseTensor* param_tensor, + const std::vector& scales) { std::vector tmp_data; tmp_data.reserve(param_tensor->numel()); @@ -59,7 +60,7 @@ void QuantizeConvInput(Scope* scope, const std::string& input_name, const std::string& scales_attr_name) { auto var = scope->GetVar(input_name); - if (var->Get().dtype() != phi::DataType::FLOAT32) { + if (var->Get().dtype() != phi::DataType::FLOAT32) { VLOG(0) << "Skipping convolution filter: " << input_name << " because it is detected again."; conv_op->Op()->SetAttr(scales_attr_name, std::vector(1, 1)); @@ -67,7 +68,7 @@ void QuantizeConvInput(Scope* scope, const auto scales = conv_op->Op()->GetAttrIfExists>(scales_attr_name); - auto* tensor = scope->GetVar(input_name)->GetMutable(); + auto* tensor = scope->GetVar(input_name)->GetMutable(); QuantizeParams(tensor, scales); conv_op->Op()->SetAttr(scales_attr_name, std::vector(1, 1)); } diff --git a/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass_tester.cc index e04cf388ac..f6eee81cec 100755 --- a/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/params_quantization_mkldnn_pass_tester.cc @@ -18,8 +18,6 @@ #include "paddle/fluid/imperative/type_defs.h" #include "paddle/fluid/platform/place.h" -using LoDTensor = phi::DenseTensor; - namespace paddle { namespace framework { namespace ir { @@ -48,15 +46,15 @@ struct Data { struct TestScope { void CreateTensor(const std::string& var_name, const Data& data) { auto variable = scope.Var(var_name); - auto tensor = variable->GetMutable(); + auto tensor = variable->GetMutable(); tensor->Resize(phi::make_ddim(data.getShape())); auto dptr = tensor->mutable_data(place); std::copy(data.getData().begin(), data.getData().end(), dptr); } - const LoDTensor& GetTensor(const std::string& input) const { + const phi::DenseTensor& GetTensor(const std::string& input) const { Variable* var = scope.FindVar(input); - return var->Get(); + return var->Get(); } framework::Scope* Scope() { return &scope; } diff --git a/paddle/fluid/framework/ir/mkldnn/quant_dequant_mkldnn_pass.cc b/paddle/fluid/framework/ir/mkldnn/quant_dequant_mkldnn_pass.cc index 7ba71b619d..433b9aba2e 100755 --- a/paddle/fluid/framework/ir/mkldnn/quant_dequant_mkldnn_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/quant_dequant_mkldnn_pass.cc @@ -84,7 +84,7 @@ void QuantDequantMkldnnPass::CollectInfoFromFake( "The Scales variable [%s] of dequantize op is not found.", var)); - auto* scale_tensor = var->GetMutable(); + auto* scale_tensor = var->GetMutable(); auto* scale_data = scale_tensor->data(); std::vector thresholds{}; for (int i = 0; i < scale_tensor->numel(); i++) { @@ -117,7 +117,7 @@ void QuantDequantMkldnnPass::CollectWeightScalesInfoFromONNXFormatDequantize( platform::errors::NotFound( "The Scales variable [%s] of dequantize op is not found.", var)); - auto* scale_tensor = var->GetMutable(); + auto* scale_tensor = var->GetMutable(); auto* scale_data = scale_tensor->data(); auto x_var_name = op_desc->Input("X")[0]; @@ -185,7 +185,7 @@ void QuantDequantMkldnnPass::CollectInputScalesFromQuantize( platform::errors::NotFound( "The InScale variable [%s] of quantize op is not found.", var)); - auto* scale_tensor = var->GetMutable(); + auto* scale_tensor = var->GetMutable(); auto* scale_data = scale_tensor->data(); float scale = 1.0 / scale_data[0]; if (std::isinf(scale) || std::isnan(scale)) { @@ -458,7 +458,7 @@ bool QuantDequantMkldnnPass::IsInt8Weight( if (var == nullptr) { return false; } - auto* weight_tensor = var->GetMutable(); + auto* weight_tensor = var->GetMutable(); auto* weight_data = weight_tensor->data(); bool is_int8 = true; for (int i = 0; i < weight_tensor->numel(); i++) { @@ -581,7 +581,7 @@ void QuantDequantMkldnnPass::DequantizeOpWeights( "The input persistable [%s] var of [%s] op is not found.", weight_var_name, op_desc->Type())); - auto* weight_tensor = var->GetMutable(); + auto* weight_tensor = var->GetMutable(); float* fp32_weight_data = weight_tensor->mutable_data(platform::CPUPlace()); ConvertFromINT8ToFP32( @@ -626,7 +626,7 @@ void QuantDequantMkldnnPass::DequantizeOpWeightsFromONNXFormat( "The input persistable [%s] var of [%s] op is not found.", weight_var_name, op_desc->Type())); - auto* weight_tensor = var->GetMutable(); + auto* weight_tensor = var->GetMutable(); int8_t* int8_weight_data = weight_tensor->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/mkldnn/reshape_transpose_matmul_mkldnn_fuse_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/reshape_transpose_matmul_mkldnn_fuse_pass_tester.cc index 79164a3209..111a28403f 100644 --- a/paddle/fluid/framework/ir/mkldnn/reshape_transpose_matmul_mkldnn_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/reshape_transpose_matmul_mkldnn_fuse_pass_tester.cc @@ -24,7 +24,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/mkldnn/shuffle_channel_mkldnn_detect_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/shuffle_channel_mkldnn_detect_pass_tester.cc index 95fba789ba..11c5b42af5 100644 --- a/paddle/fluid/framework/ir/mkldnn/shuffle_channel_mkldnn_detect_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/shuffle_channel_mkldnn_detect_pass_tester.cc @@ -26,7 +26,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/multihead_matmul_fuse_pass.cc b/paddle/fluid/framework/ir/multihead_matmul_fuse_pass.cc index b86615a46b..cefcca0f83 100644 --- a/paddle/fluid/framework/ir/multihead_matmul_fuse_pass.cc +++ b/paddle/fluid/framework/ir/multihead_matmul_fuse_pass.cc @@ -894,16 +894,19 @@ int MultiHeadMatmulV2FusePass::BuildFusionV2(Graph* graph, // mul (B * S * Hidden) x (Hidden * 3 * N * H) = (B * S * 3 * N * H) // bias (B * S * 3 * N * H) + bias (3 * N * H) // Transpose (B * S * 3 * N * H) -> (3 * B * N * S * H) - auto* wq_tensor = scope->FindVar(mul0_w->Name())->GetMutable(); - auto* wk_tensor = scope->FindVar(mul1_w->Name())->GetMutable(); - auto* wv_tensor = scope->FindVar(mul2_w->Name())->GetMutable(); + auto* wq_tensor = + scope->FindVar(mul0_w->Name())->GetMutable(); + auto* wk_tensor = + scope->FindVar(mul1_w->Name())->GetMutable(); + auto* wv_tensor = + scope->FindVar(mul2_w->Name())->GetMutable(); auto* bq_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); auto* bk_tensor = - scope->FindVar(eltadd1_b->Name())->GetMutable(); + scope->FindVar(eltadd1_b->Name())->GetMutable(); auto* bv_tensor = - scope->FindVar(eltadd2_b->Name())->GetMutable(); + scope->FindVar(eltadd2_b->Name())->GetMutable(); if (wq_tensor->dtype() == phi::DataType::FLOAT32) { QKVWeightsProcess( @@ -1335,16 +1338,19 @@ int MultiHeadMatmulV3FusePass::BuildFusionV3(Graph* graph, // mul (B * S * Hidden) x (Hidden * 3 * N * H) = (B * S * 3 * N * H) // bias (B * S * 3 * N * H) + bias (3 * N * H) // Transpose (B * S * 3 * N * H) -> (3 * B * N * S * H) - auto* wq_tensor = scope->FindVar(mul0_w->Name())->GetMutable(); - auto* wk_tensor = scope->FindVar(mul1_w->Name())->GetMutable(); - auto* wv_tensor = scope->FindVar(mul2_w->Name())->GetMutable(); + auto* wq_tensor = + scope->FindVar(mul0_w->Name())->GetMutable(); + auto* wk_tensor = + scope->FindVar(mul1_w->Name())->GetMutable(); + auto* wv_tensor = + scope->FindVar(mul2_w->Name())->GetMutable(); auto* bq_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); auto* bk_tensor = - scope->FindVar(eltadd1_b->Name())->GetMutable(); + scope->FindVar(eltadd1_b->Name())->GetMutable(); auto* bv_tensor = - scope->FindVar(eltadd2_b->Name())->GetMutable(); + scope->FindVar(eltadd2_b->Name())->GetMutable(); auto* wq_data = wq_tensor->mutable_data(platform::CPUPlace()); auto* wk_data = wk_tensor->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/multihead_matmul_fuse_pass_tester.cc b/paddle/fluid/framework/ir/multihead_matmul_fuse_pass_tester.cc index 93a45e4eff..cbcb83bc4c 100644 --- a/paddle/fluid/framework/ir/multihead_matmul_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/multihead_matmul_fuse_pass_tester.cc @@ -22,7 +22,7 @@ namespace ir { void AddVarToScope(Scope* param_scope, const std::string& name, const DDim& dims) { - auto* tensor = param_scope->Var(name)->GetMutable(); + auto* tensor = param_scope->Var(name)->GetMutable(); tensor->Resize(dims); tensor->mutable_data(platform::CPUPlace()); } diff --git a/paddle/fluid/framework/ir/pass_test_util.cc b/paddle/fluid/framework/ir/pass_test_util.cc index da58d61b33..8a092d5797 100644 --- a/paddle/fluid/framework/ir/pass_test_util.cc +++ b/paddle/fluid/framework/ir/pass_test_util.cc @@ -186,7 +186,7 @@ void InitLoDTensorHolder(const Scope& scope, const std::vector& dims, const T* data) { auto var = scope.FindLocalVar(var_name); - auto tensor = var->GetMutable(); + auto tensor = var->GetMutable(); auto* tensor_mem_ptr = tensor->mutable_data(phi::make_ddim(dims), place); if (data != nullptr) { std::memcpy(tensor_mem_ptr, data, tensor->memory_size()); diff --git a/paddle/fluid/framework/ir/quant_conv2d_dequant_fuse_pass.cc b/paddle/fluid/framework/ir/quant_conv2d_dequant_fuse_pass.cc index 48722ba941..cb9178f365 100644 --- a/paddle/fluid/framework/ir/quant_conv2d_dequant_fuse_pass.cc +++ b/paddle/fluid/framework/ir/quant_conv2d_dequant_fuse_pass.cc @@ -358,8 +358,8 @@ void QuantDequantFusePass::DeleteQuant(ir::Graph* graph, scope, platform::errors::InvalidArgument( "Scope in QuantDequantFuse pass should not be null.")); - const LoDTensor& input_scale_tensor = - scope->FindVar(input_scale_var_name)->Get(); + const phi::DenseTensor& input_scale_tensor = + scope->FindVar(input_scale_var_name)->Get(); PADDLE_ENFORCE_EQ( paddle::platform::is_cpu_place(input_scale_tensor.place()), true, @@ -484,8 +484,8 @@ void QuantDequantFusePass::FuseDequant(ir::Graph* graph, platform::errors::InvalidArgument( "Scales size in channel-wise dequantize op should be 2, got %d.", scales_name.size())); - const LoDTensor& channel_scale_tensor = - scope->FindVar(scales_name[0])->Get(); + const phi::DenseTensor& channel_scale_tensor = + scope->FindVar(scales_name[0])->Get(); PADDLE_ENFORCE_EQ( paddle::platform::is_cpu_place(channel_scale_tensor.place()), true, @@ -503,8 +503,8 @@ void QuantDequantFusePass::FuseDequant(ir::Graph* graph, } // Convert weight to fp32 range - auto* weight_tensor = - scope->Var(quantized_op_weight_node->Name())->GetMutable(); + auto* weight_tensor = scope->Var(quantized_op_weight_node->Name()) + ->GetMutable(); const auto& w_dims = weight_tensor->dims(); float* quantized_weight_data = weight_tensor->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/remove_padding_recover_padding_pass.cc b/paddle/fluid/framework/ir/remove_padding_recover_padding_pass.cc index 997a250151..237cb3bd3d 100644 --- a/paddle/fluid/framework/ir/remove_padding_recover_padding_pass.cc +++ b/paddle/fluid/framework/ir/remove_padding_recover_padding_pass.cc @@ -209,7 +209,7 @@ void RemovePaddingRecoverPaddingPass::ApplyImpl(ir::Graph* graph) const { // create variable in scope scope->Var(remove_padding_out_name); auto* remove_padding_out_tensor = - scope->FindVar(remove_padding_out_name)->GetMutable(); + scope->FindVar(remove_padding_out_name)->GetMutable(); remove_padding_out_tensor->mutable_data(platform::CUDAPlace()); // rename @@ -279,7 +279,8 @@ void RemovePaddingRecoverPaddingPass::ApplyImpl(ir::Graph* graph) const { // create variable in scope scope->Var(recover_padding_input_name); auto* recover_padding_input_tensor = - scope->FindVar(recover_padding_input_name)->GetMutable(); + scope->FindVar(recover_padding_input_name) + ->GetMutable(); recover_padding_input_tensor->mutable_data(platform::CUDAPlace()); // rename diff --git a/paddle/fluid/framework/ir/trt_multihead_matmul_fuse_pass.cc b/paddle/fluid/framework/ir/trt_multihead_matmul_fuse_pass.cc index 54397e2e44..4ecc9919f5 100644 --- a/paddle/fluid/framework/ir/trt_multihead_matmul_fuse_pass.cc +++ b/paddle/fluid/framework/ir/trt_multihead_matmul_fuse_pass.cc @@ -828,16 +828,19 @@ int TrtMultiHeadMatmulV2FusePass::BuildFusionV2(Graph* graph, // mul (B * S * Hidden) x (Hidden * 3 * N * H) = (B * S * 3 * N * H) // bias (B * S * 3 * N * H) + bias (3 * N * H) // Transpose (B * S * 3 * N * H) -> (3 * B * N * S * H) - auto* wq_tensor = scope->FindVar(mul0_w->Name())->GetMutable(); - auto* wk_tensor = scope->FindVar(mul1_w->Name())->GetMutable(); - auto* wv_tensor = scope->FindVar(mul2_w->Name())->GetMutable(); + auto* wq_tensor = + scope->FindVar(mul0_w->Name())->GetMutable(); + auto* wk_tensor = + scope->FindVar(mul1_w->Name())->GetMutable(); + auto* wv_tensor = + scope->FindVar(mul2_w->Name())->GetMutable(); auto* bq_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); auto* bk_tensor = - scope->FindVar(eltadd1_b->Name())->GetMutable(); + scope->FindVar(eltadd1_b->Name())->GetMutable(); auto* bv_tensor = - scope->FindVar(eltadd2_b->Name())->GetMutable(); + scope->FindVar(eltadd2_b->Name())->GetMutable(); auto* wq_data = wq_tensor->mutable_data(platform::CPUPlace()); auto* wk_data = wk_tensor->mutable_data(platform::CPUPlace()); @@ -1345,16 +1348,19 @@ int TrtMultiHeadMatmulV3FusePass::BuildFusionV3(Graph* graph, // mul (B * S * Hidden) x (Hidden * 3 * N * H) = (B * S * 3 * N * H) // bias (B * S * 3 * N * H) + bias (3 * N * H) // Transpose (B * S * 3 * N * H) -> (3 * B * N * S * H) - auto* wq_tensor = scope->FindVar(mul0_w->Name())->GetMutable(); - auto* wk_tensor = scope->FindVar(mul1_w->Name())->GetMutable(); - auto* wv_tensor = scope->FindVar(mul2_w->Name())->GetMutable(); + auto* wq_tensor = + scope->FindVar(mul0_w->Name())->GetMutable(); + auto* wk_tensor = + scope->FindVar(mul1_w->Name())->GetMutable(); + auto* wv_tensor = + scope->FindVar(mul2_w->Name())->GetMutable(); auto* bq_tensor = - scope->FindVar(eltadd0_b->Name())->GetMutable(); + scope->FindVar(eltadd0_b->Name())->GetMutable(); auto* bk_tensor = - scope->FindVar(eltadd1_b->Name())->GetMutable(); + scope->FindVar(eltadd1_b->Name())->GetMutable(); auto* bv_tensor = - scope->FindVar(eltadd2_b->Name())->GetMutable(); + scope->FindVar(eltadd2_b->Name())->GetMutable(); auto* wq_data = wq_tensor->mutable_data(platform::CPUPlace()); auto* wk_data = wk_tensor->mutable_data(platform::CPUPlace()); diff --git a/paddle/fluid/framework/ir/vit_attention_fuse_pass.cc b/paddle/fluid/framework/ir/vit_attention_fuse_pass.cc index 829c904dcf..4f61b03010 100644 --- a/paddle/fluid/framework/ir/vit_attention_fuse_pass.cc +++ b/paddle/fluid/framework/ir/vit_attention_fuse_pass.cc @@ -85,13 +85,13 @@ void VitAttentionFusePass::ApplyImpl(ir::Graph* graph) const { } // refactor W and Bias auto* w_tensor = - scope->FindVar(matmul0_in_y->Name())->GetMutable(); + scope->FindVar(matmul0_in_y->Name())->GetMutable(); auto w_dims = phi::make_ddim({w_tensor->dims()[0], 3, w_tensor->dims()[1] / 3}); w_tensor->Resize(w_dims); - auto* b_tensor = - scope->FindVar(elementwise0_in_y->Name())->GetMutable(); + auto* b_tensor = scope->FindVar(elementwise0_in_y->Name()) + ->GetMutable(); auto bias_dims = phi::make_ddim({3, b_tensor->dims()[0] / 3}); b_tensor->Resize(bias_dims); diff --git a/paddle/fluid/framework/lod_tensor.cc b/paddle/fluid/framework/lod_tensor.cc index 3bd55441bf..4a5f11712f 100644 --- a/paddle/fluid/framework/lod_tensor.cc +++ b/paddle/fluid/framework/lod_tensor.cc @@ -33,13 +33,14 @@ LoD SliceInLevel(const LoD &in, size_t level, size_t elem_begin, size_t elem_end) { - PADDLE_ENFORCE_LT(level, - in.size(), - platform::errors::InvalidArgument( - "The input LoDTensor's lod level should be less than " - "the LoD size, but received level is %d, LoD is %s.", - level, - in)); + PADDLE_ENFORCE_LT( + level, + in.size(), + platform::errors::InvalidArgument( + "The input phi::DenseTensor's lod level should be less than " + "the LoD size, but received level is %d, LoD is %s.", + level, + in)); PADDLE_ENFORCE_LT( elem_begin, elem_end, @@ -204,12 +205,12 @@ LoDAndOffset GetSubLoDAndAbsoluteOffset(const LoD &lod, } void SerializeToStream(std::ostream &os, - const LoDTensor &tensor, + const phi::DenseTensor &tensor, const platform::DeviceContext &dev_ctx) { phi::SerializeToStream(os, tensor, dev_ctx); } -void SerializeToStream(std::ostream &os, const LoDTensor &tensor) { +void SerializeToStream(std::ostream &os, const phi::DenseTensor &tensor) { platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); const platform::DeviceContext *dev_ctx; auto place = tensor.place(); @@ -217,7 +218,7 @@ void SerializeToStream(std::ostream &os, const LoDTensor &tensor) { phi::SerializeToStream(os, tensor, *dev_ctx); } -void DeserializeFromStream(std::istream &os, LoDTensor *tensor) { +void DeserializeFromStream(std::istream &os, phi::DenseTensor *tensor) { platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); const platform::DeviceContext *dev_ctx; dev_ctx = pool.Get(platform::CPUPlace()); @@ -225,7 +226,7 @@ void DeserializeFromStream(std::istream &os, LoDTensor *tensor) { } void DeserializeFromStream(std::istream &is, - LoDTensor *tensor, + phi::DenseTensor *tensor, const platform::DeviceContext &dev_ctx, const size_t &seek, const std::vector &shape) { @@ -233,7 +234,7 @@ void DeserializeFromStream(std::istream &is, } void DeserializeFromStream(std::istream &is, - LoDTensor *tensor, + phi::DenseTensor *tensor, const platform::DeviceContext &dev_ctx) { phi::DeserializeFromStream(is, tensor, dev_ctx); } @@ -255,8 +256,8 @@ LoD ConvertToOffsetBasedLoD(const LoD &length_lod) { return offset_lod; } -std::vector SplitLoDTensor( - const LoDTensor &src, const std::vector places) { +std::vector SplitLoDTensor( + const phi::DenseTensor &src, const std::vector places) { PADDLE_ENFORCE_GT(places.size(), 0, platform::errors::InvalidArgument( @@ -265,9 +266,9 @@ std::vector SplitLoDTensor( auto rank = src.dims().size(); // if rank is 0, just return #places.size() copys of src if (rank == 0) { - LoDTensor dst; + phi::DenseTensor dst; framework::TensorCopy(src, src.place(), &dst); - std::vector ret; + std::vector ret; ret.emplace_back(std::move(dst)); return ret; } @@ -278,10 +279,10 @@ std::vector SplitLoDTensor( // if batch_size is 0, just return #places.size() copys of empty // tensors. if (batch_size == 0) { - std::vector empty_results; + std::vector empty_results; empty_results.reserve(places.size()); for (size_t i = 0; i < places.size(); ++i) { - LoDTensor dst; + phi::DenseTensor dst; dst.Resize(src.dims()); dst.mutable_data(places[i], src.dtype()); if (!src.lod().empty()) { @@ -294,7 +295,7 @@ std::vector SplitLoDTensor( auto step_width = (batch_size + places.size() - 1) / places.size(); auto result_size = (batch_size + step_width - 1) / step_width; - std::vector results; + std::vector results; results.reserve(result_size); for (size_t i = 0; i < result_size; ++i) { @@ -308,7 +309,7 @@ std::vector SplitLoDTensor( begin, end)); - LoDTensor dst; + phi::DenseTensor dst; if (src.lod().empty()) { auto sliced_src = src.Slice(begin, end); auto &dst_place = places[i]; @@ -338,8 +339,8 @@ std::vector SplitLoDTensor( return results; } -void MergeLoDTensor(LoDTensor *target, - const std::vector &lod_tensors, +void MergeLoDTensor(phi::DenseTensor *target, + const std::vector &lod_tensors, platform::Place dst_place) { PADDLE_ENFORCE_EQ(lod_tensors.empty(), false, @@ -368,7 +369,8 @@ void MergeLoDTensor(LoDTensor *target, new_type, framework::TransToProtoVarType(t->dtype()), platform::errors::InvalidArgument( - "LoDTensor data type does not match, expected type is %s, actual " + "phi::DenseTensor data type does not match, expected type is %s, " + "actual " "type is %s.", DataTypeToString(new_type), DataTypeToString(framework::TransToProtoVarType(t->dtype())))); @@ -376,7 +378,7 @@ void MergeLoDTensor(LoDTensor *target, new_layout, t->layout(), platform::errors::InvalidArgument( - "LoDTensor layout does not match, expected layout is %s, " + "phi::DenseTensor layout does not match, expected layout is %s, " "actual layout is %s.", phi::DataLayoutToString(new_layout), phi::DataLayoutToString(t->layout()))); @@ -384,13 +386,13 @@ void MergeLoDTensor(LoDTensor *target, PADDLE_ENFORCE_EQ(tensor_dims.size(), new_dim.size(), platform::errors::InvalidArgument( - "dimensions of LoDTensor does not match")); + "dimensions of DenseTensor does not match")); for (int j = 1; j < t->dims().size(); j++) { PADDLE_ENFORCE_EQ( tensor_dims[j], new_dim[j], platform::errors::InvalidArgument( - "LoDTensor.ddim[%d] should eaqual to %d, but is %d", + "DenseTensor.ddim[%d] should eaqual to %d, but is %d", j, new_dim[j], tensor_dims[j])); @@ -401,13 +403,14 @@ void MergeLoDTensor(LoDTensor *target, } auto &lod = t->lod(); - PADDLE_ENFORCE_EQ(new_lod.size(), - lod.size(), - platform::errors::InvalidArgument( - "The LoD information of LoDTensor does not match, " - "expected LoD is %s, actual LoD is %s.", - new_lod, - lod)); + PADDLE_ENFORCE_EQ( + new_lod.size(), + lod.size(), + platform::errors::InvalidArgument( + "The LoD information of phi::DenseTensor does not match, " + "expected LoD is %s, actual LoD is %s.", + new_lod, + lod)); for (size_t j = 0; j < lod.size(); ++j) { auto &sub_lod = new_lod[j]; size_t offset = sub_lod.back(); diff --git a/paddle/fluid/framework/lod_tensor.h b/paddle/fluid/framework/lod_tensor.h index dec38ae386..78d4c47cb4 100644 --- a/paddle/fluid/framework/lod_tensor.h +++ b/paddle/fluid/framework/lod_tensor.h @@ -31,14 +31,12 @@ limitations under the License. */ namespace paddle { namespace framework { -using LoDTensor = phi::DenseTensor; - // Split phi::DenseTensor and copy to each place specified in places. -std::vector SplitLoDTensor( - const LoDTensor& src, const std::vector places); +std::vector SplitLoDTensor( + const phi::DenseTensor& src, const std::vector places); -void MergeLoDTensor(LoDTensor* target, - const std::vector& lod_tensors, +void MergeLoDTensor(phi::DenseTensor* target, + const std::vector& lod_tensors, platform::Place dst_place); /* @@ -105,25 +103,25 @@ bool CheckAbsLoD(const LoD& in, int tensor_height = -1); /* * Expand the `source` to fit the LoD of `lod`. For example, a `source` - * LoDTensor is + * phi::DenseTensor is * - LoD: [0, 2] * - tensor: [a0, a1] * a `lod` is * - LoD: [0 3 5] - * returns a new LoDTensor + * returns a new phi::DenseTensor * - [a0 a0 a0 a1 a1] */ template -LoDTensor LodExpand(const LoDTensor& source, - const LoD& lod, - size_t level, - const platform::Place& place) { +phi::DenseTensor LodExpand(const phi::DenseTensor& source, + const LoD& lod, + size_t level, + const platform::Place& place) { LoD abs_lod = ToAbsOffset(lod); const auto& lod_level = lod[level]; size_t num_instances = source.dims()[0]; // new tensor - LoDTensor tensor; + phi::DenseTensor tensor; tensor.set_lod(lod); auto dims = source.dims(); dims[0] = lod_level.back(); @@ -134,7 +132,8 @@ LoDTensor LodExpand(const LoDTensor& source, num_instances, lod_level.size() - 1, platform::errors::InvalidArgument( - "The input LoDTensor instance number should be equal to the LoD " + "The input phi::DenseTensor instance number should be equal to the " + "LoD " "level size minus 1." "The input instance number is %zu, LoD level size is %zu.", num_instances, @@ -167,27 +166,27 @@ std::pair> GetSubLoDAndAbsoluteOffset( const LoD& lod, size_t start_idx, size_t end_idx, size_t start_level); /* - * Serialize/Desiralize LoDTensor to std::ostream + * Serialize/Desiralize phi::DenseTensor to std::ostream * You can pass ofstream or ostringstream to serilize to file * or to a in memory string. GPU tensor will be copied to CPU. */ void SerializeToStream(std::ostream& os, - const LoDTensor& tensor, + const phi::DenseTensor& tensor, const platform::DeviceContext& dev_ctx); void DeserializeFromStream(std::istream& is, - LoDTensor* tensor, + phi::DenseTensor* tensor, const platform::DeviceContext& dev_ctx); void DeserializeFromStream(std::istream& is, - LoDTensor* tensor, + phi::DenseTensor* tensor, const platform::DeviceContext& dev_ctx, const size_t& seek, const std::vector& shape); LoD ConvertToOffsetBasedLoD(const LoD& length_lod); -void SerializeToStream(std::ostream& os, const LoDTensor& tensor); +void SerializeToStream(std::ostream& os, const phi::DenseTensor& tensor); -void DeserializeFromStream(std::istream& os, LoDTensor* tensor); +void DeserializeFromStream(std::istream& os, phi::DenseTensor* tensor); } // namespace framework } // namespace paddle diff --git a/paddle/fluid/framework/lod_tensor_test.cc b/paddle/fluid/framework/lod_tensor_test.cc index 254e70231e..6682a3dd37 100644 --- a/paddle/fluid/framework/lod_tensor_test.cc +++ b/paddle/fluid/framework/lod_tensor_test.cc @@ -23,14 +23,14 @@ namespace paddle { namespace framework { TEST(LoD, PrintLoDTensor) { - LoDTensor tensor1; + phi::DenseTensor tensor1; tensor1.Resize({2}); tensor1.mutable_data(platform::CPUPlace()); tensor1.data()[0] = 0.2; tensor1.data()[1] = 0.5; LOG(INFO) << tensor1; - LoDTensor tensor2; + phi::DenseTensor tensor2; tensor2.Resize({2}); tensor2.mutable_data(platform::CPUPlace()); tensor2.data()[0] = 1; @@ -51,7 +51,7 @@ TEST(LoD, data) { TEST(LoD, ExpandLoD) { LoD lod{{0, 2}}; - LoDTensor tensor; + phi::DenseTensor tensor; tensor.set_lod(lod); tensor.Resize({2, 1}); tensor.mutable_data(platform::CPUPlace()); @@ -132,7 +132,7 @@ TEST(LoD, SplitLoDTensor) { lod.push_back(std::vector({0, 1, 6, 8, 13, 15, 20})); platform::CPUPlace place; - LoDTensor lod_tensor; + phi::DenseTensor lod_tensor; lod_tensor.Resize({20, 1}); float* dst_ptr = lod_tensor.mutable_data(place); for (int i = 0; i < lod_tensor.numel(); ++i) { @@ -159,7 +159,7 @@ TEST(LoD, SplitLoDTensorWithZeroBatchSize) { lod.push_back(std::vector({0})); platform::CPUPlace place; - LoDTensor lod_tensor; + phi::DenseTensor lod_tensor; lod_tensor.Resize({0, 5}); lod_tensor.mutable_data(place); lod_tensor.set_lod(lod); @@ -181,7 +181,7 @@ TEST(LoD, MergeLoDTensor) { platform::CPUPlace place; - LoDTensor lod_tensor0; + phi::DenseTensor lod_tensor0; LoD lod0; lod0.push_back(std::vector({0, 2, 4})); lod0.push_back(std::vector({0, 1, 6, 8, 13})); @@ -193,7 +193,7 @@ TEST(LoD, MergeLoDTensor) { dst_ptr[i] = i; } - LoDTensor lod_tensor1; + phi::DenseTensor lod_tensor1; LoD lod1; lod1.push_back(std::vector({0, 1, 2})); lod1.push_back(std::vector({0, 2, 7})); @@ -204,7 +204,7 @@ TEST(LoD, MergeLoDTensor) { dst_ptr[i] = i; } - LoDTensor lod_tensor2; + phi::DenseTensor lod_tensor2; LoD lod2; lod2.push_back(std::vector({0})); lod2.push_back(std::vector({0})); @@ -212,9 +212,10 @@ TEST(LoD, MergeLoDTensor) { lod_tensor2.Resize({0}); dst_ptr = lod_tensor2.mutable_data(place); - std::vector lods{&lod_tensor0, &lod_tensor1, &lod_tensor2}; + std::vector lods{ + &lod_tensor0, &lod_tensor1, &lod_tensor2}; - LoDTensor lod_tensor; + phi::DenseTensor lod_tensor; MergeLoDTensor(&lod_tensor, lods, place); EXPECT_EQ(lod_tensor.lod(), lod); } diff --git a/paddle/fluid/framework/lod_tensor_test.cu b/paddle/fluid/framework/lod_tensor_test.cu index c45d1468b4..f4054e580f 100644 --- a/paddle/fluid/framework/lod_tensor_test.cu +++ b/paddle/fluid/framework/lod_tensor_test.cu @@ -52,7 +52,7 @@ TEST(LoD, data) { } } -TEST(LoDTensor, LoDInGPU) { +TEST(DenseTensor, LoDInGPU) { paddle::framework::InitDevices(); phi::DenseTensor lod_tensor; diff --git a/paddle/fluid/framework/multi_trainer.cc b/paddle/fluid/framework/multi_trainer.cc old mode 100755 new mode 100644 index 11afe6f280..2a101e8f00 --- a/paddle/fluid/framework/multi_trainer.cc +++ b/paddle/fluid/framework/multi_trainer.cc @@ -141,10 +141,11 @@ void MultiTrainer::InitTrainerEnv(const ProgramDesc& main_program, if (root_var->IsType()) { continue; } - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = + root_var->GetMutable(); auto* ptr = scope->Var(name); InitializeVariable(ptr, proto::VarType::LOD_TENSOR); - LoDTensor* thread_tensor = ptr->GetMutable(); + phi::DenseTensor* thread_tensor = ptr->GetMutable(); TensorCopy(*root_tensor, place, thread_tensor); } } @@ -213,9 +214,9 @@ void MultiTrainer::MergeDenseParam() { for (auto& name : trainable_param_) { VLOG(2) << "merge var " << name << " to root scope"; Variable* root_var = root_scope_->FindVar(name); - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); Variable* var = thread_scope->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); TensorCopySync((*tensor), root_tensor->place(), root_tensor); } } else { @@ -225,9 +226,10 @@ void MultiTrainer::MergeDenseParam() { for (auto& name : varnames) { VLOG(2) << "merge var " << name << " to root scope"; Variable* root_var = root_scope_->FindVar(name); - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = + root_var->GetMutable(); Variable* var = thread_scope->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); TensorCopySync((*tensor), root_tensor->place(), root_tensor); } } @@ -237,11 +239,12 @@ void MultiTrainer::MergeDenseParam() { #endif template -void MultiTrainer::MergeToRootScope(LoDTensor* root_tensor, LoDTensor* tensor) { - LoDTensor tmp_root; +void MultiTrainer::MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* tensor) { + phi::DenseTensor tmp_root; TensorCopy(*root_tensor, platform::CPUPlace(), &tmp_root); T* tmp_root_data = tmp_root.data(); - LoDTensor tmp_tensor; + phi::DenseTensor tmp_tensor; TensorCopy(*tensor, platform::CPUPlace(), &tmp_tensor); T* data = tmp_tensor.data(); for (int i = 0; i < tmp_tensor.numel(); i++) { @@ -259,7 +262,7 @@ void MultiTrainer::Finalize() { if (root_var == nullptr) { continue; } - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); for (int j = 1; j < thread_num_; j++) { Scope* cur_thread_scope = workers_[j]->GetThreadScope(); @@ -268,7 +271,8 @@ void MultiTrainer::Finalize() { if (thread_var == nullptr) { continue; } - LoDTensor* thread_tensor = thread_var->GetMutable(); + phi::DenseTensor* thread_tensor = + thread_var->GetMutable(); #define MergeCallback(cpp_type, proto_type) \ do { \ if (framework::TransToProtoVarType(root_tensor->dtype()) == proto_type) { \ diff --git a/paddle/fluid/framework/naive_executor.cc b/paddle/fluid/framework/naive_executor.cc index ee04cef32e..eb4ad8d0da 100644 --- a/paddle/fluid/framework/naive_executor.cc +++ b/paddle/fluid/framework/naive_executor.cc @@ -130,7 +130,7 @@ void NaiveExecutor::CreateOps(const ProgramDesc &desc, } } -LoDTensor *NaiveExecutor::FindTensor(const std::string &name) { +phi::DenseTensor *NaiveExecutor::FindTensor(const std::string &name) { PADDLE_ENFORCE_NOT_NULL(scope_, platform::errors::PreconditionNotMet( "Need to init scope in NaiveExecutor firstly.")); @@ -138,7 +138,7 @@ LoDTensor *NaiveExecutor::FindTensor(const std::string &name) { PADDLE_ENFORCE_NOT_NULL( var, platform::errors::NotFound("No variable [%s] in current scope.", name)); - auto *tensor = const_cast(&var->Get()); + auto *tensor = const_cast(&var->Get()); return tensor; } diff --git a/paddle/fluid/framework/naive_executor.h b/paddle/fluid/framework/naive_executor.h index 62aa6a2e0e..02b2249dea 100644 --- a/paddle/fluid/framework/naive_executor.h +++ b/paddle/fluid/framework/naive_executor.h @@ -64,7 +64,7 @@ class NaiveExecutor { void Run(); // Get an tensor to operating directly, without the need for feed_ops. - LoDTensor* FindTensor(const std::string& name); + phi::DenseTensor* FindTensor(const std::string& name); Scope* scope() { return scope_; } diff --git a/paddle/fluid/framework/new_executor/garbage_collector/event_garbage_collector.cc b/paddle/fluid/framework/new_executor/garbage_collector/event_garbage_collector.cc index 6133d6ece8..813119e410 100644 --- a/paddle/fluid/framework/new_executor/garbage_collector/event_garbage_collector.cc +++ b/paddle/fluid/framework/new_executor/garbage_collector/event_garbage_collector.cc @@ -61,8 +61,8 @@ void InterpreterCoreEventGarbageCollector::Add( return; } - if (var->IsType()) { - Add(var->GetMutable()->MoveMemoryHolder(), event, ctx); + if (var->IsType()) { + Add(var->GetMutable()->MoveMemoryHolder(), event, ctx); } else if (var->IsType< operators::reader:: OrderedMultiDeviceLoDTensorBlockingQueueHolder>()) { diff --git a/paddle/fluid/framework/new_executor/garbage_collector/fast_garbage_collector.cc b/paddle/fluid/framework/new_executor/garbage_collector/fast_garbage_collector.cc index f6ed094887..9d3984908a 100644 --- a/paddle/fluid/framework/new_executor/garbage_collector/fast_garbage_collector.cc +++ b/paddle/fluid/framework/new_executor/garbage_collector/fast_garbage_collector.cc @@ -27,8 +27,8 @@ void InterpreterCoreFastGarbageCollector::Add(Variable* var) { return; } - if (var->IsType()) { - Add(var->GetMutable()->MoveMemoryHolder()); + if (var->IsType()) { + Add(var->GetMutable()->MoveMemoryHolder()); } else if (var->IsType< operators::reader:: OrderedMultiDeviceLoDTensorBlockingQueueHolder>()) { diff --git a/paddle/fluid/framework/new_executor/garbage_collector/no_event_garbage_collector.cc b/paddle/fluid/framework/new_executor/garbage_collector/no_event_garbage_collector.cc index bbe7659ab0..ca51b90482 100644 --- a/paddle/fluid/framework/new_executor/garbage_collector/no_event_garbage_collector.cc +++ b/paddle/fluid/framework/new_executor/garbage_collector/no_event_garbage_collector.cc @@ -42,8 +42,8 @@ void InterpreterCoreNoEventGarbageCollector::Add( return; } - if (var->IsType()) { - Add(var->GetMutable()->MoveMemoryHolder(), ctx); + if (var->IsType()) { + Add(var->GetMutable()->MoveMemoryHolder(), ctx); } else if (var->IsType< operators::reader:: OrderedMultiDeviceLoDTensorBlockingQueueHolder>()) { diff --git a/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc b/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc index 3c6a0740a5..efe10fcd5f 100644 --- a/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc +++ b/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc @@ -202,7 +202,7 @@ void DataTranferHelper::RunAndConstructOpFuncNode( // Var is initialized && var contains tensor && tensor is initialized bool IsTensorOfVarInitialized(Variable* var) { if (var->IsInitialized()) { - if (var->IsType() || var->IsType()) { + if (var->IsType() || var->IsType()) { return GetLoDTensorOrSelectedRowsValueFromVar(*var)->IsInitialized(); } else if (var->IsType()) { return static_cast( @@ -456,7 +456,7 @@ void ApplyDataTransform(const OpKernelType& expected_kernel_key, std::string new_var_name; bool is_transferred = false; - if (var->IsType() || var->IsType()) { + if (var->IsType() || var->IsType()) { tensor_in = GetLoDTensorOrSelectedRowsValueFromVar(*var); } else if (var->IsType()) { if (var->Get().size() == 0) { @@ -478,7 +478,7 @@ void ApplyDataTransform(const OpKernelType& expected_kernel_key, // In such situation corressponding resized Var // has to be created and registered if ((tensor_in->layout() == DataLayout::kMKLDNN) && - (var->IsType() == true) && + (var->IsType() == true) && (expected_kernel_key.data_layout_ != DataLayout::kMKLDNN) && (paddle::platform::MKLDNNDeviceContext::tls() .get_cur_paddle_data_layout() == DataLayout::kNHWC)) { diff --git a/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc b/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc index 120d00e427..a2979efc45 100644 --- a/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc +++ b/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc @@ -718,9 +718,9 @@ void BuildOpFuncList(const platform::Place& place, } VLOG(6) << "Erase variable " << var_name; - if (var->IsType()) { + if (var->IsType()) { garbages->emplace_back( - var->GetMutable()->MoveMemoryHolder()); + var->GetMutable()->MoveMemoryHolder()); } } delete garbages; // free mem diff --git a/paddle/fluid/framework/new_executor/interpretercore.cc b/paddle/fluid/framework/new_executor/interpretercore.cc index 2bc2652688..3eb4db03f7 100644 --- a/paddle/fluid/framework/new_executor/interpretercore.cc +++ b/paddle/fluid/framework/new_executor/interpretercore.cc @@ -455,8 +455,8 @@ void InterpreterCore::BuildInplace() { auto invar = local_scope->FindVar(invar_name); auto outvar = local_scope->FindVar(outvar_name); - if (invar && outvar && invar->IsType() && - outvar->IsType() && + if (invar && outvar && invar->IsType() && + outvar->IsType() && skip_inplace_outvars.find(outvar_name) == skip_inplace_outvars.end()) { instr.AddInplace(invar, outvar); @@ -550,7 +550,7 @@ void InterpreterCore::Convert( HasLocalScope() ? local_scope_ : var_scope_.GetMutableScope(); paddle::framework::Variable* var = inner_scope->FindVar(var_scope_.GetNameById(var_id)); - if (var->IsType() || var->IsType() || + if (var->IsType() || var->IsType() || var->IsType()) { last_live_ops_[var_id].insert(op_idx); } else { @@ -635,8 +635,8 @@ void InterpreterCore::BuildSkipShareLoDInfo() { bool can_skip_lod = true; for (auto& input : vec_instruction_[i].InnerRuntimeContext()->inputs) { for (auto& var : input.second) { - if (var->IsType()) { - if (var->Get().lod().size() != 0) { + if (var->IsType()) { + if (var->Get().lod().size() != 0) { can_skip_lod = false; break; } @@ -1014,8 +1014,8 @@ void InterpreterCore::RecordStreamForGC(const Instruction& instr) { continue; } - if (var->IsType()) { - TensorRecordStream(*(var->GetMutable())); + if (var->IsType()) { + TensorRecordStream(*(var->GetMutable())); } else if (var->IsType< operators::reader:: OrderedMultiDeviceLoDTensorBlockingQueueHolder>()) { diff --git a/paddle/fluid/framework/new_executor/new_executor_defs.cc b/paddle/fluid/framework/new_executor/new_executor_defs.cc index 87c271f77f..02be9f47ec 100644 --- a/paddle/fluid/framework/new_executor/new_executor_defs.cc +++ b/paddle/fluid/framework/new_executor/new_executor_defs.cc @@ -195,7 +195,7 @@ void InterpretercoreInferShapeContext::ShareDim(const std::string& in, out_lod_tensor->Resize(in_lod_tensor.dims()); } else { PADDLE_THROW(platform::errors::Unimplemented( - "Currently, the input type of ShareDim only can be LoDTensor " + "Currently, the input type of ShareDim only can be phi::DenseTensor " "or SelectedRows.")); } } @@ -231,16 +231,17 @@ void InterpretercoreInferShapeContext::ShareAllLoD( } Variable* in_var = in_var_list[i]; - if (!in_var->IsType()) return; + if (!in_var->IsType()) return; Variable* out_var = out_var_list[i]; - PADDLE_ENFORCE_EQ(out_var->IsType(), - true, - platform::errors::PreconditionNotMet( - "The %d-th output of Output(%s) must be LoDTensor.", - i, - out_var_names[i])); - auto& in_tensor = in_var->Get(); - auto* out_tensor = out_var->GetMutable(); + PADDLE_ENFORCE_EQ( + out_var->IsType(), + true, + platform::errors::PreconditionNotMet( + "The %d-th output of Output(%s) must be phi::DenseTensor.", + i, + out_var_names[i])); + auto& in_tensor = in_var->Get(); + auto* out_tensor = out_var->GetMutable(); out_tensor->set_lod(in_tensor.lod()); #ifdef PADDLE_WITH_MKLDNN if (in_tensor.layout() != DataLayout::kMKLDNN) @@ -281,15 +282,15 @@ void InterpretercoreInferShapeContext::ShareLoD(const std::string& in, j)); Variable* in_var = in_it->second.at(i); - if (!in_var->IsType()) return; + if (!in_var->IsType()) return; Variable* out_var = out_it->second.at(j); PADDLE_ENFORCE_EQ( - out_var->IsType(), + out_var->IsType(), true, platform::errors::InvalidArgument( - "The %zu-th output of Output(%s) must be LoDTensor.", j, out)); - auto& in_tensor = in_var->Get(); - auto* out_tensor = out_var->GetMutable(); + "The %zu-th output of Output(%s) must be phi::DenseTensor.", j, out)); + auto& in_tensor = in_var->Get(); + auto* out_tensor = out_var->GetMutable(); out_tensor->set_lod(in_tensor.lod()); // TODO(dzhwinter) : reuse ShareLoD in most operators. @@ -436,13 +437,13 @@ void InterpretercoreInferShapeContext::SetSkipLoD(bool skip) { DDim InterpretercoreInferShapeContext::GetDim(Variable* var) const { PADDLE_ENFORCE_NOT_NULL( var, platform::errors::InvalidArgument("Input variable is nullptr.")); - if (var->IsType()) { - return var->Get().dims(); + if (var->IsType()) { + return var->Get().dims(); } else if (var->IsType()) { return var->Get().GetCompleteDims(); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Only LoDTensor or SelectedRows support 'GetDim', but input " + "Only phi::DenseTensor or SelectedRows support 'GetDim', but input " "Variable's type is %s.", ToTypeName(var->Type()))); } @@ -466,13 +467,14 @@ std::vector InterpretercoreInferShapeContext::GetRepeatedDims( } void InterpretercoreInferShapeContext::SetDim(Variable* var, const DDim& dim) { - if (var->IsType()) { - var->GetMutable()->Resize(dim); + if (var->IsType()) { + var->GetMutable()->Resize(dim); } else if (var->IsType()) { var->GetMutable()->set_height(dim[0]); } else { PADDLE_THROW(platform::errors::Unimplemented( - "Variable type error, expect LoDTensor or SelectedRows, but received " + "Variable type error, expect phi::DenseTensor or SelectedRows, but " + "received " "(%s).", ToTypeName(var->Type()))); } diff --git a/paddle/fluid/framework/new_executor/standalone_executor_test.cc b/paddle/fluid/framework/new_executor/standalone_executor_test.cc index a483de6f21..f625f133ed 100644 --- a/paddle/fluid/framework/new_executor/standalone_executor_test.cc +++ b/paddle/fluid/framework/new_executor/standalone_executor_test.cc @@ -199,7 +199,7 @@ TEST(InterpreterCore, skip_gc_vars) { auto* local_scope = scope.kids().back(); for (const std::string& var_name : vars) { ASSERT_EQ(local_scope->FindVar(var_name) - ->GetMutable() + ->GetMutable() ->IsInitialized(), is_skip_gc); } @@ -216,7 +216,7 @@ TEST(InterpreterCore, skip_gc_vars) { void TestShareWorkQueue(const ProgramDesc& prog, const std::vector& feed_names, - const std::vector& feed_tensors, + const std::vector& feed_tensors, const std::vector& fetch_names, const std::vector& fetch_results) { const platform::CPUPlace place = platform::CPUPlace(); @@ -233,7 +233,7 @@ void TestShareWorkQueue(const ProgramDesc& prog, FetchList fetch_list = core->Run(feed_names, feed_tensors); for (size_t i = 0; i < fetch_list.size(); ++i) { const float* fetch_data = - PADDLE_GET_CONST(LoDTensor, fetch_list[i]).data(); + PADDLE_GET_CONST(phi::DenseTensor, fetch_list[i]).data(); ASSERT_FLOAT_EQ(*fetch_data, fetch_results.at(i)); } }; @@ -266,8 +266,8 @@ TEST(InterpreterCore, workqueue_multiplexing) { phi::DDim dims = phi::make_ddim({2, 2}); const platform::CPUPlace place = platform::CPUPlace(); - LoDTensor tensor_a = LoDTensor(); - LoDTensor tensor_b = LoDTensor(); + phi::DenseTensor tensor_a = phi::DenseTensor(); + phi::DenseTensor tensor_b = phi::DenseTensor(); std::copy_n(data_a, 4, tensor_a.mutable_data(dims, place)); std::copy_n(data_b, 4, tensor_b.mutable_data(dims, place)); diff --git a/paddle/fluid/framework/op_desc.cc b/paddle/fluid/framework/op_desc.cc index fc3a8bf24d..0c783f7de4 100644 --- a/paddle/fluid/framework/op_desc.cc +++ b/paddle/fluid/framework/op_desc.cc @@ -148,7 +148,8 @@ class CompileTimeInferShapeContext : public InferShapeContext { auto *out_var = block_.FindVarRecursive(out_var_names[i]); if (in_var->GetType() != proto::VarType::LOD_TENSOR && in_var->GetType() != proto::VarType::LOD_TENSOR_ARRAY) { - VLOG(3) << "input " << in << " is not LoDTensor or LoDTensorArray."; + VLOG(3) << "input " << in + << " is not phi::DenseTensor or LoDTensorArray."; return; } out_var->SetLoDLevel(in_var->GetLoDLevel()); @@ -185,7 +186,8 @@ class CompileTimeInferShapeContext : public InferShapeContext { auto *out_var = block_.FindVarRecursive(Outputs(out)[j]); if (in_var->GetType() != proto::VarType::LOD_TENSOR && in_var->GetType() != proto::VarType::LOD_TENSOR_ARRAY) { - VLOG(3) << "input " << in << " is not LoDTensor or LoDTensorArray."; + VLOG(3) << "input " << in + << " is not phi::DenseTensor or LoDTensorArray."; return; } out_var->SetLoDLevel(in_var->GetLoDLevel()); diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc index 5f03a504d4..f3c2f6c4b2 100644 --- a/paddle/fluid/framework/operator.cc +++ b/paddle/fluid/framework/operator.cc @@ -81,8 +81,8 @@ static DDim GetDimsDebug(const Scope& scope, return DDim({-1}); } - if (var->IsType()) { - const LoDTensor& tensor = var->Get(); + if (var->IsType()) { + const phi::DenseTensor& tensor = var->Get(); return tensor.dims(); } else if (var->IsType()) { if (get_actual_dim) { @@ -109,8 +109,8 @@ static std::string GetDtype(const Scope& scope, const std::string& name) { return ""; } - if (var->IsType()) { - const LoDTensor& tensor = var->Get(); + if (var->IsType()) { + const phi::DenseTensor& tensor = var->Get(); if (UNLIKELY(!tensor.IsInitialized())) { return ""; } @@ -140,8 +140,8 @@ static std::string GetPlace(const Scope& scope, const std::string& name) { return sstream.str(); }; - if (var->IsType()) { - const LoDTensor& tensor = var->Get(); + if (var->IsType()) { + const phi::DenseTensor& tensor = var->Get(); if (UNLIKELY(!tensor.IsInitialized())) { return ""; } @@ -179,8 +179,8 @@ static LoD GetLoDDebug(const Scope& scope, const std::string& name) { return default_lod; } - if (var->IsType()) { - const LoDTensor& tensor = var->Get(); + if (var->IsType()) { + const phi::DenseTensor& tensor = var->Get(); return tensor.lod(); } else { return default_lod; @@ -531,25 +531,25 @@ void OperatorBase::GenerateTemporaryNames() { const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar( const Variable& var) { - if (var.IsType()) { - return static_cast(&(var.Get())); + if (var.IsType()) { + return static_cast(&(var.Get())); } else if (var.IsType()) { return &(var.Get().value()); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Variable type is %s, expect LoDTensor or SelectedRows.", + "Variable type is %s, expect phi::DenseTensor or SelectedRows.", ToTypeName(var.Type()))); } } phi::DenseTensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var) { - if (var->IsType()) { - return var->GetMutable(); + if (var->IsType()) { + return var->GetMutable(); } else if (var->IsType()) { return var->GetMutable()->mutable_value(); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Variable type is %s, expect LoDTensor or SelectedRows.", + "Variable type is %s, expect phi::DenseTensor or SelectedRows.", ToTypeName(var->Type()))); } } @@ -624,13 +624,14 @@ ExecutionContext::MultiInput(const std::string& name) const { std::back_inserter(res), [&](const Variable* var) -> const phi::DenseTensor* { if (var == nullptr) return nullptr; - PADDLE_ENFORCE_EQ(var->IsType(), - true, - platform::errors::InvalidArgument( - "Input variable should be LoDTensor, " - "but the received type is %s.", - ToTypeName(var->Type()))); - return &(var->Get()); + PADDLE_ENFORCE_EQ( + var->IsType(), + true, + platform::errors::InvalidArgument( + "Input variable should be phi::DenseTensor, " + "but the received type is %s.", + ToTypeName(var->Type()))); + return &(var->Get()); }); return res; } @@ -650,7 +651,7 @@ std::vector ExecutionContext::MultiOutput( std::back_inserter(res), [&](Variable* var) -> phi::DenseTensor* { return var == nullptr ? nullptr - : var->GetMutable(); + : var->GetMutable(); }); return res; } @@ -857,7 +858,7 @@ class RuntimeInferShapeContext : public InferShapeContext { out_lod_tensor->Resize(in_lod_tensor.dims()); } else { PADDLE_THROW(platform::errors::Unimplemented( - "Currently, the input type of ShareDim only can be LoDTensor " + "Currently, the input type of ShareDim only can be phi::DenseTensor " "or SelectedRows.")); } } @@ -894,16 +895,17 @@ class RuntimeInferShapeContext : public InferShapeContext { } Variable* in_var = in_var_list[i]; - if (!in_var->IsType()) return; + if (!in_var->IsType()) return; Variable* out_var = out_var_list[i]; - PADDLE_ENFORCE_EQ(out_var->IsType(), - true, - platform::errors::PreconditionNotMet( - "The %d-th output of Output(%s) must be LoDTensor.", - i, - out_var_names[i])); - auto& in_tensor = in_var->Get(); - auto* out_tensor = out_var->GetMutable(); + PADDLE_ENFORCE_EQ( + out_var->IsType(), + true, + platform::errors::PreconditionNotMet( + "The %d-th output of Output(%s) must be phi::DenseTensor.", + i, + out_var_names[i])); + auto& in_tensor = in_var->Get(); + auto* out_tensor = out_var->GetMutable(); out_tensor->set_lod(in_tensor.lod()); #ifdef PADDLE_WITH_MKLDNN if (in_tensor.layout() != DataLayout::kMKLDNN) @@ -942,15 +944,17 @@ class RuntimeInferShapeContext : public InferShapeContext { j)); Variable* in_var = in_it->second.at(i); - if (!in_var->IsType()) return; + if (!in_var->IsType()) return; Variable* out_var = out_it->second.at(j); PADDLE_ENFORCE_EQ( - out_var->IsType(), + out_var->IsType(), true, platform::errors::InvalidArgument( - "The %zu-th output of Output(%s) must be LoDTensor.", j, out)); - auto& in_tensor = in_var->Get(); - auto* out_tensor = out_var->GetMutable(); + "The %zu-th output of Output(%s) must be phi::DenseTensor.", + j, + out)); + auto& in_tensor = in_var->Get(); + auto* out_tensor = out_var->GetMutable(); out_tensor->set_lod(in_tensor.lod()); // TODO(dzhwinter) : reuse ShareLoD in most operators. @@ -1083,13 +1087,13 @@ class RuntimeInferShapeContext : public InferShapeContext { DDim GetDim(Variable* var) const { PADDLE_ENFORCE_NOT_NULL( var, platform::errors::InvalidArgument("Input variable is nullptr.")); - if (var->IsType()) { - return var->Get().dims(); + if (var->IsType()) { + return var->Get().dims(); } else if (var->IsType()) { return var->Get().GetCompleteDims(); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "Only LoDTensor or SelectedRows support 'GetDim', but input " + "Only phi::DenseTensor or SelectedRows support 'GetDim', but input " "Variable's type is %s.", ToTypeName(var->Type()))); } @@ -1111,13 +1115,14 @@ class RuntimeInferShapeContext : public InferShapeContext { } void SetDim(Variable* var, const DDim& dim) { - if (var->IsType()) { - var->GetMutable()->Resize(dim); + if (var->IsType()) { + var->GetMutable()->Resize(dim); } else if (var->IsType()) { var->GetMutable()->set_height(dim[0]); } else { PADDLE_THROW(platform::errors::Unimplemented( - "Variable type error, expect LoDTensor or SelectedRows, but received " + "Variable type error, expect phi::DenseTensor or SelectedRows, but " + "received " "(%s).", ToTypeName(var->Type()))); } @@ -2218,7 +2223,7 @@ Scope* OperatorWithKernel::PrepareData( // In such situation corressponding resized Var // has to be created and registered if ((tensor_in->layout() == DataLayout::kMKLDNN) && - (var->IsType() == true) && + (var->IsType() == true) && (expected_kernel_key.data_layout_ != DataLayout::kMKLDNN) && (paddle::platform::MKLDNNDeviceContext::tls() .get_cur_paddle_data_layout() == DataLayout::kNHWC) && @@ -2229,7 +2234,7 @@ Scope* OperatorWithKernel::PrepareData( } auto* trans_var = new_scope->Var(var_name); in_vars->at(i) = trans_var; - auto out = trans_var->GetMutable(); + auto out = trans_var->GetMutable(); out->Resize(tensor_in->dims()); platform::MatchShapeToLayout( out, tensor_in->layout(), DataLayout::kNHWC); @@ -2432,8 +2437,8 @@ void OperatorWithKernel::ParseInputDataType( const phi::DenseTensor* t = nullptr; if (var->IsType()) { t = &var->Get(); - } else if (var->IsType()) { - t = &var->Get(); + } else if (var->IsType()) { + t = &var->Get(); } else if (var->IsType()) { t = &(var->Get().value()); } else if (var->IsType()) { @@ -2480,8 +2485,8 @@ void OperatorWithKernel::ParseMultiInputDataType( const phi::DenseTensor* t = nullptr; if (var->IsType()) { t = &var->Get(); - } else if (var->IsType()) { - t = &var->Get(); + } else if (var->IsType()) { + t = &var->Get(); } else if (var->IsType()) { t = &(var->Get().value()); } else if (var->IsType()) { @@ -2577,7 +2582,7 @@ proto::VarType::Type OperatorWithKernel::IndicateVarDataType( dafault_data_type, platform::errors::InvalidArgument( "The Input Variable(%s) of (%s) Operator used to determine kernel " - "data type is empty or not LoDTensor or SelectedRows or " + "data type is empty or not phi::DenseTensor or SelectedRows or " "LoDTensorArray.", name, Type())); @@ -2600,8 +2605,8 @@ phi::DenseTensor* OperatorWithKernel::GetTensorFormInputSafely( phi::DenseTensor* t = nullptr; if (var->IsType()) { t = var->GetMutable(); - } else if (var->IsType()) { - t = var->GetMutable(); + } else if (var->IsType()) { + t = var->GetMutable(); } else if (var->IsType()) { t = var->GetMutable()->mutable_value(); } else { diff --git a/paddle/fluid/framework/operator.h b/paddle/fluid/framework/operator.h index 5acec948ec..31c7797a63 100644 --- a/paddle/fluid/framework/operator.h +++ b/paddle/fluid/framework/operator.h @@ -121,7 +121,7 @@ inline std::string GradOriginalVarName(const std::string& grad_var_name) { } inline bool VarIsTensor(const Variable& var) { - return var.IsType() || var.IsType(); + return var.IsType() || var.IsType(); } const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar( diff --git a/paddle/fluid/framework/operator_test.cc b/paddle/fluid/framework/operator_test.cc index 1b58984c29..80455bc98e 100644 --- a/paddle/fluid/framework/operator_test.cc +++ b/paddle/fluid/framework/operator_test.cc @@ -341,7 +341,8 @@ class IndicateLoDTensorDataTypeTest : public OperatorWithKernel { void InferShape(framework::InferShapeContext* ctx) const override {} OpKernelType GetExpectedKernelType( const ExecutionContext& ctx) const override { - auto data_type = OperatorWithKernel::IndicateVarDataType(ctx, "LoDTensor"); + auto data_type = + OperatorWithKernel::IndicateVarDataType(ctx, "phi::DenseTensor"); return framework::OpKernelType(data_type, ctx.device_context()); } }; @@ -349,7 +350,7 @@ class IndicateLoDTensorDataTypeTest : public OperatorWithKernel { class IndicateLoDTensorDataTypeTestProtoMaker : public OpProtoAndCheckerMaker { public: void Make() { - AddInput("LoDTensor", "Input of phi::DenseTensor type Variable."); + AddInput("phi::DenseTensor", "Input of phi::DenseTensor type Variable."); AddComment("This Op is only for IndicateVarDataType interface test."); } }; @@ -432,7 +433,7 @@ TEST(IndicateVarDataTypeTest, lodtensor) { paddle::framework::InitDevices(); paddle::framework::proto::OpDesc op_desc; op_desc.set_type("indicate_lod_tensor_data_type_test"); - BuildVar("LoDTensor", {"lodtensor_1"}, op_desc.add_inputs()); + BuildVar("phi::DenseTensor", {"lodtensor_1"}, op_desc.add_inputs()); paddle::platform::CPUPlace cpu_place; paddle::framework::Scope scope; @@ -450,7 +451,7 @@ TEST(IndicateVarDataTypeTest, lodtensor) { EXPECT_TRUE( ex_msg.find( "The indicate_lod_tensor_data_type_test Op's Input Variable " - "`LoDTensor` contains uninitialized phi::DenseTensor.") != + "`phi::DenseTensor` contains uninitialized phi::DenseTensor.") != std::string::npos); } ASSERT_TRUE(caught); @@ -502,13 +503,11 @@ TEST(IndicateVarDataTypeTest, other) { } catch (paddle::platform::EnforceNotMet& err) { caught = true; std::string ex_msg = err.what(); - EXPECT_TRUE( - ex_msg.find( - "The Input Variable(Other) of " - "(indicate_other_data_type_test) Operator used to " - "determine kernel data type " - "is empty or not LoDTensor or SelectedRows or LoDTensorArray.") != - std::string::npos); + EXPECT_TRUE(ex_msg.find("The Input Variable(Other) of " + "(indicate_other_data_type_test) Operator used to " + "determine kernel data type " + "is empty or not phi::DenseTensor or SelectedRows " + "or LoDTensorArray.") != std::string::npos); } ASSERT_TRUE(caught); } @@ -583,8 +582,8 @@ class SetLoDLevelTest : public OperatorWithKernel { class GetSetLoDLevelTestMaker : public OpProtoAndCheckerMaker { public: void Make() { - AddInput("X", "(LoDTensor) Input Variable."); - AddOutput("Out", "(LoDTensor) Output Variable."); + AddInput("X", "(phi::DenseTensor) Input Variable."); + AddOutput("Out", "(phi::DenseTensor) Output Variable."); AddComment("This Op is only for Get/SetLoDLevel interface test."); } }; diff --git a/paddle/fluid/framework/paddle2cinn/cinn_cache_key.cc b/paddle/fluid/framework/paddle2cinn/cinn_cache_key.cc index 5518af3a62..90bb7337f2 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_cache_key.cc +++ b/paddle/fluid/framework/paddle2cinn/cinn_cache_key.cc @@ -36,7 +36,7 @@ CinnCacheKey::CinnCacheKey(GraphHashStrategy graph_hash) CinnCacheKey::CinnCacheKey( const ir::Graph& graph, - const std::map& input_tensors, + const std::map& input_tensors, const std::string& arch_str, GraphHashStrategy graph_hash) : graph_hash_(graph_hash) { @@ -53,7 +53,7 @@ CinnCacheKey::CinnCacheKey(const ir::Graph& graph, void CinnCacheKey::SetKey( const ir::Graph& graph, - const std::map& input_tensors, + const std::map& input_tensors, const std::string& arch_str) { graph_hash_val_ = graph_hash_(graph); for (const auto& name_tensor : input_tensors) { diff --git a/paddle/fluid/framework/paddle2cinn/cinn_cache_key.h b/paddle/fluid/framework/paddle2cinn/cinn_cache_key.h index 9c175a84c4..008a7f4579 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_cache_key.h +++ b/paddle/fluid/framework/paddle2cinn/cinn_cache_key.h @@ -38,10 +38,11 @@ class CinnCacheKey { explicit CinnCacheKey(GraphHashStrategy graph_hash); - CinnCacheKey(const ir::Graph& graph, - const std::map& input_tensors, - const std::string& arch_str, - GraphHashStrategy graph_hash); + CinnCacheKey( + const ir::Graph& graph, + const std::map& input_tensors, + const std::string& arch_str, + GraphHashStrategy graph_hash); CinnCacheKey(const ir::Graph& graph, const std::map& input_shapes, const std::string& arch_str, @@ -49,9 +50,10 @@ class CinnCacheKey { ~CinnCacheKey() = default; - void SetKey(const ir::Graph& graph, - const std::map& input_tensors, - const std::string& arch_str); + void SetKey( + const ir::Graph& graph, + const std::map& input_tensors, + const std::string& arch_str); void SetKey(const ir::Graph& graph, const std::map& input_shapes, const std::string& arch_str); @@ -70,23 +72,23 @@ class CinnCacheKey { std::string arch_str_; }; -#define CINN_CACHE_KEY_CREATE(NAME) \ - class NAME : public CinnCacheKey { \ - public: \ - NAME() : CinnCacheKey(HashGraph) {} \ - \ - NAME(const ir::Graph& graph, \ - const std::map& input_tensors, \ - const std::string& arch_str) \ - : CinnCacheKey(graph, input_tensors, arch_str, HashGraph) {} \ - \ - NAME(const ir::Graph& graph, \ - const std::map& input_shapes, \ - const std::string& arch_str) \ - : CinnCacheKey(graph, input_shapes, arch_str, HashGraph) {} \ - \ - private: \ - static size_t HashGraph(const ir::Graph& graph); \ +#define CINN_CACHE_KEY_CREATE(NAME) \ + class NAME : public CinnCacheKey { \ + public: \ + NAME() : CinnCacheKey(HashGraph) {} \ + \ + NAME(const ir::Graph& graph, \ + const std::map& input_tensors, \ + const std::string& arch_str) \ + : CinnCacheKey(graph, input_tensors, arch_str, HashGraph) {} \ + \ + NAME(const ir::Graph& graph, \ + const std::map& input_shapes, \ + const std::string& arch_str) \ + : CinnCacheKey(graph, input_shapes, arch_str, HashGraph) {} \ + \ + private: \ + static size_t HashGraph(const ir::Graph& graph); \ }; // Class to store the keys by graph address for compiling CINN. diff --git a/paddle/fluid/framework/paddle2cinn/cinn_cache_key_test.cc b/paddle/fluid/framework/paddle2cinn/cinn_cache_key_test.cc index 95bbab1fc4..959ebf8aad 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_cache_key_test.cc +++ b/paddle/fluid/framework/paddle2cinn/cinn_cache_key_test.cc @@ -39,10 +39,10 @@ TEST(CinnCacheKeyTest, TestAsUnorderedKeyByStructure) { x->SetType(proto::VarType::LOD_TENSOR); ir::Graph graph(program); - LoDTensor tensor; + phi::DenseTensor tensor; tensor.Resize({1, 2, 3}); - const LoDTensor *tensor_pointer = &tensor; - std::map feed_tensors = { + const phi::DenseTensor *tensor_pointer = &tensor; + std::map feed_tensors = { {"X", tensor_pointer}}; DDim ddim = phi::make_ddim({1, 2, 3}); @@ -59,7 +59,7 @@ TEST(CinnCacheKeyTest, TestAsUnorderedKeyByStructure) { EXPECT_EQ(cache_key3, cache_key4); CinnCacheKeyByStructure cache_key5( - empty_graph, std::map(), "unk"); + empty_graph, std::map(), "unk"); CinnCacheKeyByStructure cache_key6( empty_graph, std::map(), "unk"); EXPECT_EQ(cache_key5, cache_key6); @@ -112,10 +112,10 @@ TEST(CinnCacheKeyTest, TestAsUnorderedKeyByAddress) { x->SetType(proto::VarType::LOD_TENSOR); ir::Graph graph(program); - LoDTensor tensor; + phi::DenseTensor tensor; tensor.Resize({1, 2, 3}); - const LoDTensor *tensor_pointer = &tensor; - std::map feed_tensors = { + const phi::DenseTensor *tensor_pointer = &tensor; + std::map feed_tensors = { {"X", tensor_pointer}}; DDim ddim = phi::make_ddim({1, 2, 3}); @@ -132,7 +132,7 @@ TEST(CinnCacheKeyTest, TestAsUnorderedKeyByAddress) { EXPECT_EQ(cache_key3, cache_key4); CinnCacheKeyByAddress cache_key5( - empty_graph, std::map(), "unk"); + empty_graph, std::map(), "unk"); CinnCacheKeyByAddress cache_key6( empty_graph, std::map(), "unk"); EXPECT_EQ(cache_key5, cache_key6); @@ -186,10 +186,10 @@ TEST(CinnCacheKeyTest, TestSameGraph) { x2->SetType(proto::VarType::LOD_TENSOR); ir::Graph graph2(program2); - LoDTensor tensor; + phi::DenseTensor tensor; tensor.Resize({1, 2, 3}); - const LoDTensor *tensor_pointer = &tensor; - std::map feed_tensors = { + const phi::DenseTensor *tensor_pointer = &tensor; + std::map feed_tensors = { {"X", tensor_pointer}}; CinnCacheKeyByAddress cache_key_by_address1(graph1, feed_tensors, "x86"); diff --git a/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc b/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc index 48b5b73b4c..899d417727 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc +++ b/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc @@ -67,7 +67,7 @@ CinnCompiler *CinnCompiler::GetInstance() { const CinnCompiledObject &CinnCompiler::Compile( const Graph &graph, - const std::map &input_tensors, + const std::map &input_tensors, const Target &target, void *stream) { VLOG(4) << "-- The graph to be compiled is:\n" << VizGraph(graph); @@ -107,7 +107,7 @@ const CinnCompiledObject &CinnCompiler::Compile( const CinnCompiledObject &CinnCompiler::Compile( int64_t compilation_key, - const std::map &input_tensors, + const std::map &input_tensors, const Target &target, void *stream) { const auto &graph = FindGraph(compilation_key); @@ -236,7 +236,7 @@ void CinnCompiler::Clear() { void CinnCompiler::CheckCompiledValid( const ir::Graph &graph, - const std::map &input_tensors, + const std::map &input_tensors, const CinnCompiledObject &compiled_obj) const { const auto &input_var_names = graph.Get>(kInputVars); const auto &output_var_names = @@ -264,7 +264,7 @@ void CinnCompiler::CheckCompiledValid( std::unique_ptr CinnCompiler::CompileGraph( const ir::Graph &graph, - const std::map &input_tensors, + const std::map &input_tensors, const Target &target, std::int64_t compiled_num, void *stream) const { diff --git a/paddle/fluid/framework/paddle2cinn/cinn_compiler.h b/paddle/fluid/framework/paddle2cinn/cinn_compiler.h index d193afce9d..b3a26781fa 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_compiler.h +++ b/paddle/fluid/framework/paddle2cinn/cinn_compiler.h @@ -75,13 +75,13 @@ class CinnCompiler { const CinnCompiledObject& Compile( const ir::Graph& graph, - const std::map& input_tensors, + const std::map& input_tensors, const ::cinn::common::Target& target, void* stream = nullptr); const CinnCompiledObject& Compile( int64_t compilation_key, - const std::map& input_tensors, + const std::map& input_tensors, const ::cinn::common::Target& target, void* stream = nullptr); @@ -109,7 +109,7 @@ class CinnCompiler { CinnCompiler() = default; std::unique_ptr CompileGraph( const ir::Graph& graph, - const std::map& input_tensors, + const std::map& input_tensors, const ::cinn::common::Target& target, std::int64_t compiled_num, void* stream = nullptr) const; @@ -118,7 +118,7 @@ class CinnCompiler { // the consistency of external variables of the subgraph void CheckCompiledValid( const ir::Graph& graph, - const std::map& input_tensors, + const std::map& input_tensors, const CinnCompiledObject& compiled_obj) const; std::unordered_map> graphs_; diff --git a/paddle/fluid/framework/paddle2cinn/cinn_compiler_test.cc b/paddle/fluid/framework/paddle2cinn/cinn_compiler_test.cc index db2f899101..4e9257c061 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_compiler_test.cc +++ b/paddle/fluid/framework/paddle2cinn/cinn_compiler_test.cc @@ -254,13 +254,13 @@ TEST(CinnCompilerTest, Compile) { EXPECT_THROW(cinn_compiler->FindGraph(0), paddle::platform::EnforceNotMet); auto inputs_info = GetInputsInfo(compilation_key, *graph); - std::unordered_map create_inputs; + std::unordered_map create_inputs; for (const auto& pair : inputs_info) { auto& tensor = create_inputs[pair.first]; tensor.Resize(phi::make_ddim(pair.second)); tensor.mutable_data(platform::CPUPlace()); } - std::map input_tensors; + std::map input_tensors; std::for_each(create_inputs.begin(), create_inputs.end(), [&input_tensors](const auto& val) { diff --git a/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization.h b/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization.h index 0061aa5489..a0f3c6a93b 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization.h +++ b/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization.h @@ -66,7 +66,7 @@ class CinnGraphSymbolization { int64_t graph_id, const ir::Graph& graph, const ::cinn::common::Target& target, - const std::map& input_tensors) + const std::map& input_tensors) : graph_id_(graph_id), graph_(graph), target_(target), @@ -99,7 +99,7 @@ class CinnGraphSymbolization { const int64_t graph_id_; const ir::Graph& graph_; const ::cinn::common::Target& target_; - const std::map& input_tensors_; + const std::map& input_tensors_; // preserve cinn variable map std::unordered_map var_map_; diff --git a/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization_test.cc b/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization_test.cc index 12bd9564c1..db0994e970 100644 --- a/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization_test.cc +++ b/paddle/fluid/framework/paddle2cinn/cinn_graph_symbolization_test.cc @@ -88,7 +88,7 @@ class CinnGraphSymbolizationTest : public ::testing::Test { std::unique_ptr symbol_; std::unique_ptr test_; - std::map feed_targets_; + std::map feed_targets_; OpMapperContext CreateNewContext() { return test_->CreateNewContext(builder_.get(), feed_map_); @@ -101,7 +101,7 @@ class CinnGraphSymbolizationTest : public ::testing::Test { private: std::unique_ptr graph_; ::cinn::common::Target target_; - std::map feed_tensors_; + std::map feed_tensors_; std::unique_ptr builder_; FeedInfoMap feed_map_; @@ -201,11 +201,11 @@ class CinnGraphSymbolizationTest : public ::testing::Test { return ::cinn::common::DefaultHostTarget(); } - std::map CreateFeedTensors() { - std::map feed_targets; + std::map CreateFeedTensors() { + std::map feed_targets; auto create_tensor = []() { - LoDTensor tensor; + phi::DenseTensor tensor; DDim dims = {256, 1024}; tensor.Resize(dims); tensor.mutable_data( @@ -227,9 +227,9 @@ class CinnGraphSymbolizationTest : public ::testing::Test { return feed_targets; } - std::map ConvertFeedType( - const std::map& feed_targets) { - std::map res; + std::map ConvertFeedType( + const std::map& feed_targets) { + std::map res; for (auto& feed_pair : feed_targets) { res[feed_pair.first] = &feed_pair.second; } diff --git a/paddle/fluid/framework/parallel_executor.cc b/paddle/fluid/framework/parallel_executor.cc index 3b4fef8bcb..da3f087825 100644 --- a/paddle/fluid/framework/parallel_executor.cc +++ b/paddle/fluid/framework/parallel_executor.cc @@ -823,11 +823,11 @@ void ParallelExecutor::BCastParamsToDevices( // the initializing bcast, all vars would be bcast from device(0). for (auto &var : vars) { framework::Variable *main_var = member_->local_scopes_[0]->FindVar(var); - if (main_var == nullptr || !main_var->IsType()) { + if (main_var == nullptr || !main_var->IsType()) { continue; } - auto &main_tensor = main_var->Get(); + auto &main_tensor = main_var->Get(); if (!main_tensor.IsInitialized()) { VLOG(3) << "one in var not inited, return!"; continue; @@ -848,7 +848,7 @@ void ParallelExecutor::BCastParamsToDevices( buffer = const_cast(main_tensor.data()); } else { auto local_scope = member_->local_scopes_[i]; - auto *t = local_scope->Var(var)->GetMutable(); + auto *t = local_scope->Var(var)->GetMutable(); t->Resize(dims); buffer = t->mutable_data(place, main_tensor.dtype()); } @@ -918,7 +918,7 @@ void ParallelExecutor::BCastParamsToDevices( buffer = const_cast(main_tensor.data()); } else { auto local_scope = member_->local_scopes_[i]; - auto *t = local_scope->Var(var)->GetMutable(); + auto *t = local_scope->Var(var)->GetMutable(); t->Resize(dims); buffer = t->mutable_data(place, main_tensor.dtype()); } @@ -970,7 +970,7 @@ void ParallelExecutor::BCastParamsToDevices( platform::CPUPlace cpu; for (size_t i = 1; i < member_->places_.size(); ++i) { auto local_scope = member_->local_scopes_[i]; - auto *t = local_scope->Var(var)->GetMutable(); + auto *t = local_scope->Var(var)->GetMutable(); auto copy_memory = [&] { t->Resize(dims); @@ -1063,7 +1063,8 @@ void ParallelExecutor::SkipMemoryReuse( } void ParallelExecutor::FeedTensorsIntoLocalScopes( - const std::vector> &tensors) { + const std::vector> + &tensors) { if (platform::IsCUDAGraphCapturing()) { for (auto &tensor : tensors) { PADDLE_ENFORCE_EQ( @@ -1112,7 +1113,7 @@ void ParallelExecutor::FeedTensorsIntoLocalScopes( : member_->local_exec_scopes_[i]; auto *feed_var = feed_scope->Var(pair.first); - auto *trg = feed_var->GetMutable(); + auto *trg = feed_var->GetMutable(); trg->ShareDataWith(pair.second); trg->set_lod(pair.second.lod()); } @@ -1134,7 +1135,7 @@ void ParallelExecutor::FeedTensorsIntoLocalScopes( } void ParallelExecutor::FeedAndSplitTensorIntoLocalScopes( - const std::unordered_map &tensors) { + const std::unordered_map &tensors) { if (platform::IsCUDAGraphCapturing()) { PADDLE_ENFORCE_EQ( tensors.empty(), @@ -1240,7 +1241,7 @@ void ParallelExecutor::FeedAndSplitTensorIntoLocalScopes( : member_->local_exec_scopes_[j]; auto *feed_var = feed_scope->Var(pair.first); - auto t = feed_var->GetMutable(); + auto t = feed_var->GetMutable(); t->ShareDataWith(lod_tensors[j]); t->set_lod(lod_tensors[j].lod()); } diff --git a/paddle/fluid/framework/parallel_executor.h b/paddle/fluid/framework/parallel_executor.h index a3b812a71a..3251408976 100644 --- a/paddle/fluid/framework/parallel_executor.h +++ b/paddle/fluid/framework/parallel_executor.h @@ -84,10 +84,11 @@ class ParallelExecutor { * size of local scopes. */ void FeedTensorsIntoLocalScopes( - const std::vector> &tensors); + const std::vector> + &tensors); void FeedAndSplitTensorIntoLocalScopes( - const std::unordered_map &tensors); + const std::unordered_map &tensors); FetchUnmergedList Run(const std::vector &fetch_tensors); FetchList RunAndMerge(const std::vector &fetch_tensors); diff --git a/paddle/fluid/framework/ps_gpu_trainer.cc b/paddle/fluid/framework/ps_gpu_trainer.cc index 6b0cb842d8..15972fc4b8 100644 --- a/paddle/fluid/framework/ps_gpu_trainer.cc +++ b/paddle/fluid/framework/ps_gpu_trainer.cc @@ -280,10 +280,11 @@ void PSGPUTrainer::InitTrainerEnv(const ProgramDesc& main_program, if (!root_var) { continue; } - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = + root_var->GetMutable(); auto* ptr = scope->Var(name); InitializeVariable(ptr, proto::VarType::LOD_TENSOR); - LoDTensor* thread_tensor = ptr->GetMutable(); + phi::DenseTensor* thread_tensor = ptr->GetMutable(); TensorCopy(*root_tensor, place, thread_tensor); } } @@ -343,11 +344,12 @@ void PSGPUTrainer::Run() { Scope* PSGPUTrainer::GetWorkerScope(int thread_id) { return nullptr; } template -void PSGPUTrainer::MergeToRootScope(LoDTensor* root_tensor, LoDTensor* tensor) { - LoDTensor tmp_root; +void PSGPUTrainer::MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* tensor) { + phi::DenseTensor tmp_root; TensorCopySync(*root_tensor, platform::CPUPlace(), &tmp_root); T* tmp_root_data = tmp_root.data(); - LoDTensor tmp_tensor; + phi::DenseTensor tmp_tensor; TensorCopySync(*tensor, platform::CPUPlace(), &tmp_tensor); T* data = tmp_tensor.data(); for (int i = 0; i < tmp_tensor.numel(); i++) { @@ -361,9 +363,9 @@ void PSGPUTrainer::MergeDenseParam() { for (auto& name : trainable_param_) { VLOG(2) << "merge var " << name << " to root scope"; Variable* root_var = root_scope_->FindVar(name); - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); Variable* var = thread_scope->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); TensorCopySync((*tensor), root_tensor->place(), root_tensor); } } @@ -377,7 +379,7 @@ void PSGPUTrainer::Finalize() { if (root_var == nullptr) { continue; } - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); if (root_tensor == nullptr || !root_tensor->IsInitialized()) { continue; } @@ -388,7 +390,8 @@ void PSGPUTrainer::Finalize() { if (thread_var == nullptr) { continue; } - LoDTensor* thread_tensor = thread_var->GetMutable(); + phi::DenseTensor* thread_tensor = + thread_var->GetMutable(); if (thread_tensor == nullptr || !thread_tensor->IsInitialized()) { continue; } diff --git a/paddle/fluid/framework/ps_gpu_worker.cc b/paddle/fluid/framework/ps_gpu_worker.cc index b7674e06b9..c59a14e96b 100644 --- a/paddle/fluid/framework/ps_gpu_worker.cc +++ b/paddle/fluid/framework/ps_gpu_worker.cc @@ -164,7 +164,7 @@ void PSGPUWorker::TrainFiles() { if (var == nullptr) { continue; } - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); if (tensor == nullptr || !tensor->IsInitialized()) { continue; } diff --git a/paddle/fluid/framework/pull_dense_worker.cc b/paddle/fluid/framework/pull_dense_worker.cc index 979b132fdb..7b61052a20 100644 --- a/paddle/fluid/framework/pull_dense_worker.cc +++ b/paddle/fluid/framework/pull_dense_worker.cc @@ -92,10 +92,10 @@ void PullDenseWorker::CreatePinVar() { auto& name = dense_value_names_[tid][j]; Variable* var = root_scope_->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); auto* ptr = root_scope_->Var(name + "pin"); InitializeVariable(ptr, proto::VarType::LOD_TENSOR); - LoDTensor* pin_tensor = ptr->GetMutable(); + phi::DenseTensor* pin_tensor = ptr->GetMutable(); #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) pin_tensor->mutable_data(tensor->dims(), platform::CUDAPinnedPlace()); @@ -139,10 +139,10 @@ void PullDenseWorker::Wait(std::vector<::std::future>* status_vec) { auto& name = dense_value_names_[tid][j]; Variable* pin_var = root_scope_->FindVar(name + "pin"); - LoDTensor* pin_tensor = pin_var->GetMutable(); + phi::DenseTensor* pin_tensor = pin_var->GetMutable(); float* pin_w = pin_tensor->data(); Variable* var = thread_scopes_[i]->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); float* w = tensor->data(); #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) memory::Copy(places_[i], @@ -267,9 +267,9 @@ void PullDenseWorker::MergeDenseParam() { auto& name = dense_value_names_[tid][j]; Variable* root_var = root_scope_->FindVar(name); - LoDTensor* root_tensor = root_var->GetMutable(); + phi::DenseTensor* root_tensor = root_var->GetMutable(); Variable* var = thread_scopes_[0]->FindVar(name); - LoDTensor* tensor = var->GetMutable(); + phi::DenseTensor* tensor = var->GetMutable(); TensorCopy((*tensor), root_tensor->place(), root_tensor); } } diff --git a/paddle/fluid/framework/save_load_util.cc b/paddle/fluid/framework/save_load_util.cc index 053a9914a3..7db829fc70 100644 --- a/paddle/fluid/framework/save_load_util.cc +++ b/paddle/fluid/framework/save_load_util.cc @@ -133,7 +133,7 @@ bool SaveStaticNameListToDisk( "that exe.run(startup_program) has " "been executed.", vec_tensor_name_list[i])); - phi::DenseTensor* tensor = var_ptr->GetMutable(); + phi::DenseTensor* tensor = var_ptr->GetMutable(); PADDLE_ENFORCE_EQ(tensor->IsInitialized(), true, platform::errors::PreconditionNotMet( @@ -155,7 +155,7 @@ bool SaveDygraphVarBaseListToDisk( for (size_t i = 0; i < vec_var_base_list.size(); ++i) { auto var_ptr = vec_var_base_list[i]->MutableVar(); - phi::DenseTensor* tensor = var_ptr->GetMutable(); + phi::DenseTensor* tensor = var_ptr->GetMutable(); PADDLE_ENFORCE_EQ(tensor->IsInitialized(), true, @@ -216,7 +216,7 @@ bool LoadStaticNameListFromDisk( "please make sure that exe.run(startup_program) has been executed.", vec_tensor_name_list[i])); - phi::DenseTensor* tensor = var_ptr->GetMutable(); + phi::DenseTensor* tensor = var_ptr->GetMutable(); PADDLE_ENFORCE_NOT_NULL( tensor, platform::errors::PreconditionNotMet( diff --git a/paddle/fluid/framework/trainer.h b/paddle/fluid/framework/trainer.h index 7a60d5db0d..0b6150b5a8 100644 --- a/paddle/fluid/framework/trainer.h +++ b/paddle/fluid/framework/trainer.h @@ -117,7 +117,8 @@ class MultiTrainer : public TrainerBase { virtual std::string GetDumpPath(int tid); template - void MergeToRootScope(LoDTensor* root_tensor, LoDTensor* thread_tensor); + void MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* thread_tensor); #ifdef PADDLE_WITH_HETERPS void MergeDenseParam(); @@ -149,7 +150,8 @@ class DistMultiTrainer : public MultiTrainer { virtual void Run(); virtual void Finalize(); template - void MergeToRootScope(LoDTensor* root_tensor, LoDTensor* thread_tensor); + void MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* thread_tensor); virtual void InitDumpEnv(); virtual Scope* GetWorkerScope(int thread_id); virtual void RegisterHeterCallback(); @@ -207,19 +209,20 @@ class HeterXpuTrainer : public TrainerBase { virtual void InitDumpEnv() {} template #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) - void HeterMemCpy(LoDTensor* tensor, - LoDTensor* root_tensor, + void HeterMemCpy(phi::DenseTensor* tensor, + phi::DenseTensor* root_tensor, const paddle::platform::Place& thread_place, gpuStream_t stream); #endif #ifdef PADDLE_WITH_XPU - void HeterMemCpy(LoDTensor* thread_tensor, - LoDTensor* root_tensor, + void HeterMemCpy(phi::DenseTensor* thread_tensor, + phi::DenseTensor* root_tensor, const paddle::platform::Place& thread_place); #endif void CreateThreadParam(const ProgramDesc& program, int num); template - void MergeToRootScope(LoDTensor* root_tensor, LoDTensor* thread_tensor); + void MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* thread_tensor); int EndPass(const HeterRequest* request, HeterResponse* response); int StopService(const HeterRequest* request, HeterResponse* response); @@ -274,7 +277,8 @@ class PSGPUTrainer : public TrainerBase { virtual void MergeDenseParam(); template - void MergeToRootScope(LoDTensor* root_tensor, LoDTensor* thread_tensor); + void MergeToRootScope(phi::DenseTensor* root_tensor, + phi::DenseTensor* thread_tensor); void InitializeGPUServer(const TrainerDesc& trainer_desc); protected: diff --git a/paddle/fluid/framework/tuple.h b/paddle/fluid/framework/tuple.h index 0cf7c70b9b..03160d0016 100644 --- a/paddle/fluid/framework/tuple.h +++ b/paddle/fluid/framework/tuple.h @@ -32,7 +32,7 @@ typedef paddle::variant + phi::DenseTensor /*, ChannelHolder*/> ElementVar; class Tuple { diff --git a/paddle/fluid/framework/unused_var_check.cc b/paddle/fluid/framework/unused_var_check.cc index 4a27f88c32..1350dba829 100644 --- a/paddle/fluid/framework/unused_var_check.cc +++ b/paddle/fluid/framework/unused_var_check.cc @@ -106,7 +106,7 @@ void CheckUnusedVar(const OperatorBase &op, const Scope &scope) { for (auto &in_var_name : pair.second) { auto *in_var = scope.FindVar(in_var_name); if (in_var != nullptr && in_var->IsInitialized()) { - auto *tensor = &in_var->Get(); + auto *tensor = &in_var->Get(); if (tensor != nullptr && tensor->IsInitialized()) { unsed_input_var_names.emplace_back(pair.first); break; diff --git a/paddle/fluid/framework/var_type.h b/paddle/fluid/framework/var_type.h index bab027868c..29ea30255b 100644 --- a/paddle/fluid/framework/var_type.h +++ b/paddle/fluid/framework/var_type.h @@ -49,7 +49,7 @@ template inline void VisitVarType(const framework::Variable& var, Visitor visitor) { switch (var.Type()) { case proto::VarType::LOD_TENSOR: - visitor(var.Get()); + visitor(var.Get()); return; case proto::VarType::LOD_RANK_TABLE: visitor(var.Get()); diff --git a/paddle/fluid/framework/var_type_traits.h b/paddle/fluid/framework/var_type_traits.h index 2d72f4841c..eb3f90006a 100644 --- a/paddle/fluid/framework/var_type_traits.h +++ b/paddle/fluid/framework/var_type_traits.h @@ -242,7 +242,7 @@ struct VarTypeTrait { // Users should set some of variable type ids to be what is defined in // framework.proto below -REG_PROTO_VAR_TYPE_TRAIT(LoDTensor, proto::VarType::LOD_TENSOR); +REG_PROTO_VAR_TYPE_TRAIT(phi::DenseTensor, proto::VarType::LOD_TENSOR); REG_PROTO_VAR_TYPE_TRAIT(phi::SelectedRows, proto::VarType::SELECTED_ROWS); REG_PROTO_VAR_TYPE_TRAIT(std::vector, proto::VarType::STEP_SCOPES); REG_PROTO_VAR_TYPE_TRAIT(LoDRankTable, proto::VarType::LOD_RANK_TABLE); diff --git a/paddle/fluid/framework/var_type_traits_test.cc b/paddle/fluid/framework/var_type_traits_test.cc index 63eb0bef5d..48e2a9a9c6 100644 --- a/paddle/fluid/framework/var_type_traits_test.cc +++ b/paddle/fluid/framework/var_type_traits_test.cc @@ -90,7 +90,7 @@ bool CheckVarId(int proto_id) { } TEST(var_type_traits, check_proto_type_id) { - ASSERT_TRUE(CheckVarId(proto::VarType::LOD_TENSOR)); + ASSERT_TRUE(CheckVarId(proto::VarType::LOD_TENSOR)); ASSERT_TRUE(CheckVarId(proto::VarType::SELECTED_ROWS)); ASSERT_TRUE(CheckVarId>(proto::VarType::STEP_SCOPES)); ASSERT_TRUE(CheckVarId(proto::VarType::LOD_RANK_TABLE)); diff --git a/paddle/fluid/framework/variable.h b/paddle/fluid/framework/variable.h index d1c487429e..52ae587624 100644 --- a/paddle/fluid/framework/variable.h +++ b/paddle/fluid/framework/variable.h @@ -132,10 +132,10 @@ inline phi::DenseTensor::InplaceVersion* Variable::InplaceVersionCounter() { ->mutable_value() ->InplaceVersionCounter(); } else { - VLOG(4) - << "Only supports phi::DenseTensor, LoDTensor, SelectedRows to have " - "TensorInplaceVersion, but received type " - << platform::demangle(framework::ToTypeName(Type())); + VLOG(4) << "Only supports phi::DenseTensor, phi::DenseTensor, SelectedRows " + "to have " + "TensorInplaceVersion, but received type " + << platform::demangle(framework::ToTypeName(Type())); } return version_counter_ptr; } @@ -160,10 +160,10 @@ inline void Variable::BumpInplaceVersion() { if (version_counter_ptr) { return version_counter_ptr->Bump(); } else { - VLOG(4) - << "Only supports phi::DenseTensor, LoDTensor, SelectedRows to have " - "TensorInplaceVersion, but received type " - << platform::demangle(framework::ToTypeName(Type())); + VLOG(4) << "Only supports phi::DenseTensor, phi::DenseTensor, SelectedRows " + "to have " + "TensorInplaceVersion, but received type " + << platform::demangle(framework::ToTypeName(Type())); } } } // namespace framework diff --git a/paddle/fluid/framework/variable_helper.cc b/paddle/fluid/framework/variable_helper.cc index 07b5982827..6f0beeb0b7 100644 --- a/paddle/fluid/framework/variable_helper.cc +++ b/paddle/fluid/framework/variable_helper.cc @@ -29,7 +29,7 @@ namespace framework { void InitializeVariable(Variable *var, proto::VarType::Type var_type) { if (var_type == proto::VarType::LOD_TENSOR) { - var->GetMutable(); + var->GetMutable(); } else if (var_type == proto::VarType::SELECTED_ROWS) { var->GetMutable(); } else if (var_type == proto::VarType::FEED_MINIBATCH) { diff --git a/paddle/fluid/inference/analysis/passes/convert_to_mixed_precision.cc b/paddle/fluid/inference/analysis/passes/convert_to_mixed_precision.cc index 789865a528..219ce6d17e 100644 --- a/paddle/fluid/inference/analysis/passes/convert_to_mixed_precision.cc +++ b/paddle/fluid/inference/analysis/passes/convert_to_mixed_precision.cc @@ -814,7 +814,7 @@ void ConvertToMixedPrecisionPass::SaveMixedModel() { scope_.FindVar(param), platform::errors::NotFound( "Block should already have a '%s' variable", param)); - auto* tensor = scope_.FindVar(param)->GetMutable(); + auto* tensor = scope_.FindVar(param)->GetMutable(); framework::SerializeToStream(os, *tensor, ctx); } return os.str(); diff --git a/paddle/fluid/inference/analysis/passes/ir_params_sync_among_devices_pass.cc b/paddle/fluid/inference/analysis/passes/ir_params_sync_among_devices_pass.cc index e772674b99..6711c60ff8 100644 --- a/paddle/fluid/inference/analysis/passes/ir_params_sync_among_devices_pass.cc +++ b/paddle/fluid/inference/analysis/passes/ir_params_sync_among_devices_pass.cc @@ -163,7 +163,7 @@ void IrParamsSyncAmongDevicesPass::CopyParamsToGpu(Argument *argument) { VLOG(5) << "var_name is " << var_name << ", data type is " << var_data_type; platform::CPUPlace cpu_place; - framework::LoDTensor temp_tensor; + phi::DenseTensor temp_tensor; temp_tensor.Resize(t->dims()); paddle::framework::TensorCopySync(*t, cpu_place, &temp_tensor); t->clear(); diff --git a/paddle/fluid/inference/tensorrt/convert/fused_lookup_tables_op.cc b/paddle/fluid/inference/tensorrt/convert/fused_lookup_tables_op.cc index d34d322ce1..80e89185c2 100644 --- a/paddle/fluid/inference/tensorrt/convert/fused_lookup_tables_op.cc +++ b/paddle/fluid/inference/tensorrt/convert/fused_lookup_tables_op.cc @@ -66,7 +66,7 @@ class FusedLookupTablesOpConverter : public OpConverter { TensorRTEngine::Weight weight; auto* w_var = scope.FindVar(w_name); - auto* w_tensor = w_var->GetMutable(); + auto* w_tensor = w_var->GetMutable(); auto w_dims = w_tensor->dims(); weight = engine_->GetTrtWeight(w_name, *w_tensor); auto weight_size = phi::product(w_dims); diff --git a/paddle/fluid/inference/tensorrt/convert/merge_layernorm_op.cc b/paddle/fluid/inference/tensorrt/convert/merge_layernorm_op.cc index d47ad62d65..0a69d622a4 100644 --- a/paddle/fluid/inference/tensorrt/convert/merge_layernorm_op.cc +++ b/paddle/fluid/inference/tensorrt/convert/merge_layernorm_op.cc @@ -50,8 +50,8 @@ class MergeLayernormOpConverter : public OpConverter { platform::errors::InvalidArgument( "The begin_norm_axis of LayernormShiftPartition should be %d", begin_norm_axis)); - auto* Bias_t = Bias_v->GetMutable(); - auto* Scale_t = Scale_v->GetMutable(); + auto* Bias_t = Bias_v->GetMutable(); + auto* Scale_t = Scale_v->GetMutable(); auto bias_weight = engine_->GetFp32TrtWeight(op_desc.Input("Bias").front(), *Bias_t); diff --git a/paddle/fluid/inference/tensorrt/test_dynamic_engine.cc b/paddle/fluid/inference/tensorrt/test_dynamic_engine.cc index ddf0ec5dd3..0fc959a14b 100644 --- a/paddle/fluid/inference/tensorrt/test_dynamic_engine.cc +++ b/paddle/fluid/inference/tensorrt/test_dynamic_engine.cc @@ -101,9 +101,9 @@ class TensorRTDynamicShapeValueEngineTest : public ::testing::Test { } protected: - framework::LoDTensor input_; - framework::LoDTensor shape_; - framework::LoDTensor output_; + phi::DenseTensor input_; + phi::DenseTensor shape_; + phi::DenseTensor output_; TensorRTEngine *engine_; phi::GPUContext *ctx_; }; diff --git a/paddle/fluid/operators/share_buffer_op_test.cc b/paddle/fluid/operators/share_buffer_op_test.cc index 60220981ca..98e560e771 100644 --- a/paddle/fluid/operators/share_buffer_op_test.cc +++ b/paddle/fluid/operators/share_buffer_op_test.cc @@ -52,17 +52,17 @@ TEST(test_share_buffer_op, test_share_buffer_op) { Scope scope; for (size_t i = 0; i < n; ++i) { - auto *in_tensor = scope.Var(inputs[i])->GetMutable(); + auto *in_tensor = scope.Var(inputs[i])->GetMutable(); in_tensor->Resize(dims[i]); in_tensor->mutable_data(place); - scope.Var(outputs[i])->GetMutable(); + scope.Var(outputs[i])->GetMutable(); } op->Run(scope, place); platform::DeviceContextPool::Instance().Get(place)->Wait(); for (size_t i = 0; i < n; ++i) { - const auto &in_tensor = scope.Var(inputs[i])->Get(); - const auto &out_tensor = scope.Var(outputs[i])->Get(); + const auto &in_tensor = scope.Var(inputs[i])->Get(); + const auto &out_tensor = scope.Var(outputs[i])->Get(); EXPECT_TRUE(out_tensor.IsSharedBufferWith(in_tensor)); } } diff --git a/paddle/fluid/pybind/parallel_executor.cc b/paddle/fluid/pybind/parallel_executor.cc index 02be0e9693..6c49aa7b88 100644 --- a/paddle/fluid/pybind/parallel_executor.cc +++ b/paddle/fluid/pybind/parallel_executor.cc @@ -1055,7 +1055,7 @@ void BindParallelExecutor(pybind11::module &m) { // NOLINT }) .def("device_count", &ParallelExecutor::DeviceCount); using VarQuantScale = - std::unordered_map>; + std::unordered_map>; py::class_> pass(m, "Pass"); pass.def(py::init()) .def("has", &ir::Pass::Has) diff --git a/paddle/fluid/pybind/pybind.cc b/paddle/fluid/pybind/pybind.cc index c5898b9762..e55ecefb4a 100644 --- a/paddle/fluid/pybind/pybind.cc +++ b/paddle/fluid/pybind/pybind.cc @@ -935,8 +935,8 @@ All parameter, weight, gradient are variables in Paddle. [](const Variable &var) -> float { return var.Get(); }) .def( "get_tensor", - [](Variable &self) -> LoDTensor * { - return self.GetMutable(); + [](Variable &self) -> phi::DenseTensor * { + return self.GetMutable(); }, py::return_value_policy::reference) .def("get_bytes", @@ -1615,7 +1615,7 @@ All parameter, weight, gradient are variables in Paddle. [](Executor &self, ExecutorPrepareContext *ctx, Scope *scope, - std::map *feed_targets, + std::map *feed_targets, std::map *fetch_targets, bool create_local_scope = true, bool create_vars = true, @@ -1817,7 +1817,7 @@ All parameter, weight, gradient are variables in Paddle. m.def("set_feed_variable", static_cast(&framework::SetFeedVariable)); m.def("set_feed_variable", @@ -1832,7 +1832,7 @@ All parameter, weight, gradient are variables in Paddle. size_t index) -> py::object { auto &var = framework::GetFetchVariable(scope, var_name, index); if (data_is_lod_tensor(var)) { - return py::cast(PADDLE_GET(LoDTensor, var)); + return py::cast(PADDLE_GET(phi::DenseTensor, var)); } else { return py::cast(PADDLE_GET(LoDTensorArray, var)); } @@ -1883,7 +1883,7 @@ All parameter, weight, gradient are variables in Paddle. py::return_value_policy::reference) .def("__len__", [](LoDTensorArray &self) { return self.size(); }) .def("__setitem__", - [](LoDTensorArray &self, size_t i, const LoDTensor &t) { + [](LoDTensorArray &self, size_t i, const phi::DenseTensor &t) { PADDLE_ENFORCE_LT(i, self.size(), platform::errors::InvalidArgument( @@ -1894,7 +1894,7 @@ All parameter, weight, gradient are variables in Paddle. }) .def( "append", - [](LoDTensorArray &self, const LoDTensor &t) { + [](LoDTensorArray &self, const phi::DenseTensor &t) { self.emplace_back(); self.back().ShareDataWith(t); self.back().set_lod(t.lod()); @@ -1941,7 +1941,7 @@ All parameter, weight, gradient are variables in Paddle. py::list res(self.size()); for (size_t i = 0; i < self.size(); ++i) { if (data_is_lod_tensor(self[i])) { - auto &data = PADDLE_GET(LoDTensor, self[i]); + auto &data = PADDLE_GET(phi::DenseTensor, self[i]); res[i] = py::cast(std::move(data)); } else if (data_is_sparse_coo_tensor(self[i])) { auto &data = PADDLE_GET(phi::SparseCooTensor, self[i]); @@ -1962,9 +1962,9 @@ All parameter, weight, gradient are variables in Paddle. .def( "append", - [](FetchList &self, const LoDTensor &t) { + [](FetchList &self, const phi::DenseTensor &t) { self.emplace_back(); - auto &lod_tensor = PADDLE_GET(LoDTensor, self.back()); + auto &lod_tensor = PADDLE_GET(phi::DenseTensor, self.back()); lod_tensor.ShareDataWith(t); lod_tensor.set_lod(t.lod()); }, @@ -1993,7 +1993,7 @@ All parameter, weight, gradient are variables in Paddle. py::list tmp(self[i].size()); for (size_t j = 0; j < self[i].size(); ++j) { if (data_is_lod_tensor(self[i][j])) { - auto &var = PADDLE_GET(LoDTensor, self[i][j]); + auto &var = PADDLE_GET(phi::DenseTensor, self[i][j]); tmp[j] = py::cast(std::move(var)); } else { auto &var = PADDLE_GET(LoDTensorArray, self[i][j]); -- GitLab