From 11862d4e079d829d1d8ffa3f6b1cf39b59ca6bdd Mon Sep 17 00:00:00 2001 From: baoachun <962571062@qq.com> Date: Wed, 16 Mar 2022 03:32:20 +0000 Subject: [PATCH] update code --- paddle/fluid/inference/api/analysis_config.cc | 15 ++++++----- .../fluid/inference/api/analysis_predictor.cc | 2 +- .../api/analysis_predictor_tester.cc | 26 +++++++++++++++++++ .../inference/api/paddle_analysis_config.h | 14 +++------- .../inference/api/paddle_pass_builder.cc | 2 +- .../fluid/inference/api/paddle_pass_builder.h | 4 +-- paddle/fluid/pybind/inference_api.cc | 5 ++-- 7 files changed, 45 insertions(+), 23 deletions(-) diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc index 939bb2a89ba75..d08d28a3f6233 100644 --- a/paddle/fluid/inference/api/analysis_config.cc +++ b/paddle/fluid/inference/api/analysis_config.cc @@ -105,11 +105,13 @@ void AnalysisConfig::DisableGpu() { Update(); } -void AnalysisConfig::EnableUseGpuFp16() { +void AnalysisConfig::Exp_EnableUseGpuFp16( + std::unordered_set op_list) { #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) use_gpu_fp16_ = true; + gpu_fp16_disabled_op_types_.insert(op_list.begin(), op_list.end()); #else - LOG(ERROR) << "Please compile with gpu to EnableUseGpuFp16()"; + LOG(ERROR) << "Please compile with gpu to Exp_EnableUseGpuFp16()"; use_gpu_fp16_ = false; #endif @@ -591,12 +593,13 @@ void AnalysisConfig::Update() { if (use_gpu_fp16_) { #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) if (!enable_ir_optim_) { - LOG(ERROR) - << "EnableUseGpuFp16() only works when IR optimization is enabled."; + LOG(ERROR) << "Exp_EnableUseGpuFp16() only works when IR optimization is " + "enabled."; } else if (!use_gpu()) { - LOG(ERROR) << "EnableUseGpuFp16() only works when use_gpu is enabled."; + LOG(ERROR) + << "Exp_EnableUseGpuFp16() only works when use_gpu is enabled."; } else { - pass_builder()->EnableUseGpuFp16(); + pass_builder()->Exp_EnableUseGpuFp16(); } #endif } diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc index 6ee9c5a431454..6f765ef415e9f 100644 --- a/paddle/fluid/inference/api/analysis_predictor.cc +++ b/paddle/fluid/inference/api/analysis_predictor.cc @@ -872,7 +872,7 @@ void AnalysisPredictor::PrepareArgument() { argument_.SetDlnneMinSubgraphSize(config_.dlnne_min_subgraph_size_); } - if (config_.use_gpu_fp16()) { + if (config_.gpu_fp16_enabled()) { argument_.SetUseGPUFp16(true); argument_.SetGpuFp16DisabledOpTypes(config_.gpu_fp16_disabled_op_types_); } diff --git a/paddle/fluid/inference/api/analysis_predictor_tester.cc b/paddle/fluid/inference/api/analysis_predictor_tester.cc index 2c6e8f4f1a4d9..ecb5eaf982548 100644 --- a/paddle/fluid/inference/api/analysis_predictor_tester.cc +++ b/paddle/fluid/inference/api/analysis_predictor_tester.cc @@ -375,6 +375,19 @@ TEST(AnalysisPredictor, enable_onnxruntime) { ASSERT_TRUE(!config.use_onnxruntime()); } +TEST(AnalysisPredictor, exp_enable_use_gpu_fp16) { + AnalysisConfig config; + config.SwitchIrOptim(); +#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) + config.EnableUseGpu(100, 0); + config.Exp_EnableUseGpuFp16(); + ASSERT_TRUE(config.gpu_fp16_enabled()); +#else + config.DisableGpu(); +#endif + LOG(INFO) << config.Summary(); +} + } // namespace paddle namespace paddle_infer { @@ -434,6 +447,19 @@ TEST(Predictor, EnableONNXRuntime) { auto predictor = CreatePredictor(config); } +TEST(Predictor, Exp_EnableUseGpuFp16) { + Config config; + config.SetModel(FLAGS_dirname); + config.SwitchIrOptim(); +#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) + config.EnableUseGpu(100, 0); + config.Exp_EnableUseGpuFp16(); +#else + config.DisableGpu(); +#endif + auto predictor = CreatePredictor(config); +} + TEST(Tensor, CpuShareExternalData) { Config config; config.SetModel(FLAGS_dirname); diff --git a/paddle/fluid/inference/api/paddle_analysis_config.h b/paddle/fluid/inference/api/paddle_analysis_config.h index 6b81ac0b8e363..bdfe0e46e9ca4 100644 --- a/paddle/fluid/inference/api/paddle_analysis_config.h +++ b/paddle/fluid/inference/api/paddle_analysis_config.h @@ -254,26 +254,18 @@ struct PD_INFER_DECL AnalysisConfig { /// void DisableGpu(); /// - /// \brief Turn on GPU fp16 precision. - /// - /// - void EnableUseGpuFp16(); - /// - /// \brief Specify the operator type list to keep original calculation - /// precision. + /// \brief Enable GPU fp16 precision computation, in experimental state. /// /// \param op_list The operator type list. /// - void SetGpuFp16DisabledOp(std::unordered_set op_list) { - gpu_fp16_disabled_op_types_.insert(op_list.begin(), op_list.end()); - } + void Exp_EnableUseGpuFp16(std::unordered_set op_list = {}); /// /// \brief A boolean state telling whether the GPU fp16 precision is turned /// on. /// /// \return bool Whether the GPU fp16 precision is turned on. /// - bool use_gpu_fp16() const { return use_gpu_fp16_; } + bool gpu_fp16_enabled() const { return use_gpu_fp16_; } /// /// \brief Turn on XPU. diff --git a/paddle/fluid/inference/api/paddle_pass_builder.cc b/paddle/fluid/inference/api/paddle_pass_builder.cc index abc4d4300f56c..69a2c2dd9f9d9 100644 --- a/paddle/fluid/inference/api/paddle_pass_builder.cc +++ b/paddle/fluid/inference/api/paddle_pass_builder.cc @@ -172,7 +172,7 @@ void GpuPassStrategy::EnableCUDNN() { use_cudnn_ = true; } -void GpuPassStrategy::EnableUseGpuFp16() { +void GpuPassStrategy::Exp_EnableUseGpuFp16() { passes_.assign({ "is_test_pass", // "simplify_with_basic_ops_pass", // diff --git a/paddle/fluid/inference/api/paddle_pass_builder.h b/paddle/fluid/inference/api/paddle_pass_builder.h index 5d7fa8594cad3..02290ed33ff1c 100644 --- a/paddle/fluid/inference/api/paddle_pass_builder.h +++ b/paddle/fluid/inference/api/paddle_pass_builder.h @@ -126,7 +126,7 @@ class PD_INFER_DECL PassStrategy : public PaddlePassBuilder { virtual void EnableCUDNN() {} /// \brief Enable use gpu fp16 kernel. - virtual void EnableUseGpuFp16() {} + virtual void Exp_EnableUseGpuFp16() {} /// \brief Enable the use of MKLDNN. /// The MKLDNN control exists in both CPU and GPU mode, because there can @@ -232,7 +232,7 @@ class PD_INFER_DECL GpuPassStrategy : public PassStrategy { void EnableCUDNN() override; /// \brief Enable the use of gpu fp16 kernel. - void EnableUseGpuFp16() override; + void Exp_EnableUseGpuFp16() override; /// \brief Not supported in GPU mode yet. void EnableMKLDNN() override; diff --git a/paddle/fluid/pybind/inference_api.cc b/paddle/fluid/pybind/inference_api.cc index 8c1de44ed2c8a..c8f0acd0b8a85 100644 --- a/paddle/fluid/pybind/inference_api.cc +++ b/paddle/fluid/pybind/inference_api.cc @@ -551,8 +551,9 @@ void BindAnalysisConfig(py::module *m) { .def("params_file", &AnalysisConfig::params_file) .def("enable_use_gpu", &AnalysisConfig::EnableUseGpu, py::arg("memory_pool_init_size_mb"), py::arg("device_id") = 0) - .def("enable_use_gpu_fp16", &AnalysisConfig::EnableUseGpuFp16) - .def("set_gpu_fp16_disabled_op", &AnalysisConfig::SetGpuFp16DisabledOp) + .def("exp_enable_use_gpu_fp16", &AnalysisConfig::Exp_EnableUseGpuFp16, + py::arg("gpu_fp16_disabled_op_types") = + std::unordered_set({})) .def("enable_xpu", &AnalysisConfig::EnableXpu, py::arg("l3_workspace_size") = 16 * 1024 * 1024, py::arg("locked") = false, py::arg("autotune") = true,