analysis_config.cc 13.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/framework/scope.h"
17
#include "paddle/fluid/inference/api/paddle_analysis_config.h"
18
#include "paddle/fluid/inference/api/paddle_inference_api.h"
19
#include "paddle/fluid/inference/api/paddle_pass_builder.h"
20
#include "paddle/fluid/platform/enforce.h"
21
#include "paddle/fluid/platform/gpu_info.h"
22 23

namespace paddle {
24
extern const std::vector<std::string> kTRTSubgraphPasses;
25
extern const std::vector<std::string> kAnakinSubgraphPasses;
26

27
PassStrategy *AnalysisConfig::pass_builder() const {
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
  if (!pass_builder_.get()) {
    if (use_gpu_) {
      LOG(INFO) << "Create GPU IR passes";
      pass_builder_.reset(new GpuPassStrategy);
    } else {
      LOG(INFO) << "Create CPU IR passes";
      pass_builder_.reset(new CpuPassStrategy);
    }
  } else if (pass_builder_->use_gpu() ^ use_gpu()) {
    LOG(WARNING) << "The use_gpu flag is not compatible between Config and "
                    "PassBuilder, the flags are "
                 << use_gpu() << " " << pass_builder_->use_gpu();
    LOG(WARNING) << "Please make them compatible, still use the existing "
                    "PassBuilder.";
  }

44 45 46
  return pass_builder_.get();
}

47
AnalysisConfig::AnalysisConfig(const std::string &model_dir) {
48
  model_dir_ = model_dir;
Y
Yan Chunwei 已提交
49 50

  Update();
51
}
52 53
AnalysisConfig::AnalysisConfig(const std::string &prog_file,
                               const std::string &params_file) {
54 55
  prog_file_ = prog_file;
  params_file_ = params_file;
Y
Yan Chunwei 已提交
56 57

  Update();
58
}
59 60
void AnalysisConfig::SetModel(const std::string &prog_file_path,
                              const std::string &params_file_path) {
61 62
  prog_file_ = prog_file_path;
  params_file_ = params_file_path;
Y
Yan Chunwei 已提交
63 64

  Update();
65
}
66 67
void AnalysisConfig::EnableUseGpu(uint64_t memory_pool_init_size_mb,
                                  int device_id) {
68 69 70 71 72
#ifdef PADDLE_WITH_CUDA
  use_gpu_ = true;
  memory_pool_init_size_mb_ = memory_pool_init_size_mb;
  device_id_ = device_id;
#else
Y
Yan Chunwei 已提交
73
  LOG(ERROR) << "Please compile with gpu to EnableGpu()";
74 75
  use_gpu_ = false;
#endif
Y
Yan Chunwei 已提交
76 77 78

  Update();
}
79
void AnalysisConfig::DisableGpu() {
Y
Yan Chunwei 已提交
80 81 82
  use_gpu_ = false;

  Update();
83 84
}

85
AnalysisConfig::AnalysisConfig(const AnalysisConfig &other) {
86 87 88 89 90 91
#define CP_MEMBER(member__) member__ = other.member__;

  // Model related.
  CP_MEMBER(model_dir_);
  CP_MEMBER(model_from_memory_);  // the memory model reuses prog_file_ and
                                  // params_file_ fields.
92

93
  CP_MEMBER(opt_cache_dir_);
94 95 96
  prog_file_ = std::move(other.prog_file_);
  params_file_ = std::move(other.params_file_);

97
  // GPU related.
98
  CP_MEMBER(use_gpu_);
99
  CP_MEMBER(use_cudnn_);
100 101
  CP_MEMBER(device_id_);
  CP_MEMBER(memory_pool_init_size_mb_);
Y
Yan Chunwei 已提交
102 103

  CP_MEMBER(enable_memory_optim_);
Y
Yan Chunwei 已提交
104 105
  CP_MEMBER(static_memory_optim_);
  CP_MEMBER(static_memory_optim_force_update_);
S
Sylwester Fraczek 已提交
106
  // TensorRT related.
107 108 109 110
  CP_MEMBER(use_tensorrt_);
  CP_MEMBER(tensorrt_workspace_size_);
  CP_MEMBER(tensorrt_max_batchsize_);
  CP_MEMBER(tensorrt_min_subgraph_size_);
N
nhzlx 已提交
111
  CP_MEMBER(tensorrt_precision_mode_);
N
nhzlx 已提交
112
  CP_MEMBER(trt_use_static_engine_);
113
  CP_MEMBER(trt_use_calib_mode_);
M
mozga-intel 已提交
114 115
  // NGRAPH related.
  CP_MEMBER(use_ngraph_);
S
Sylwester Fraczek 已提交
116
  // MKLDNN related.
117 118
  CP_MEMBER(use_mkldnn_);
  CP_MEMBER(mkldnn_enabled_op_types_);
119
  CP_MEMBER(mkldnn_cache_capacity_);
120 121 122
  // Quantization related.
  CP_MEMBER(use_mkldnn_quantizer_);
  CP_MEMBER(mkldnn_quantizer_config_);
123

124 125
  CP_MEMBER(use_anakin_);
  CP_MEMBER(anakin_max_batchsize_);
126
  CP_MEMBER(anakin_max_input_shape_);
127
  CP_MEMBER(anakin_min_subgraph_size_);
128 129 130 131
  CP_MEMBER(anakin_precision_mode_);
  CP_MEMBER(anakin_auto_config_layout_);
  CP_MEMBER(anakin_passes_filter_);
  CP_MEMBER(anakin_ops_filter_);
132 133 134 135 136 137 138 139 140 141 142 143

  // Ir related.
  CP_MEMBER(enable_ir_optim_);
  CP_MEMBER(use_feed_fetch_ops_);
  CP_MEMBER(ir_debug_);
  CP_MEMBER(specify_input_name_);

  CP_MEMBER(cpu_math_library_num_threads_);

  CP_MEMBER(serialized_info_cache_);

  if (use_gpu_) {
144 145 146 147 148 149 150
    pass_builder_.reset(new GpuPassStrategy(
        *static_cast<GpuPassStrategy *>(other.pass_builder())));
  } else {
    pass_builder_.reset(new CpuPassStrategy(
        *static_cast<CpuPassStrategy *>(other.pass_builder())));
  }

151
#undef CP_MEMBER
Y
Yan Chunwei 已提交
152 153

  Update();
154 155
}

156 157 158 159 160 161 162 163 164 165 166
void AnalysisConfig::EnableCUDNN() {
#ifdef PADDLE_WITH_CUDA
  use_cudnn_ = use_gpu_;
#else
  LOG(ERROR) << "Please compile with CUDA first to use cuDNN";
  use_cudnn_ = false;
#endif

  Update();
}

167
void AnalysisConfig::EnableMKLDNN() {
168 169 170 171 172 173
#ifdef PADDLE_WITH_MKLDNN
  use_mkldnn_ = true;
#else
  LOG(ERROR) << "Please compile with MKLDNN first to use MKLDNN";
  use_mkldnn_ = false;
#endif
Y
Yan Chunwei 已提交
174 175

  Update();
176 177
}

178 179 180 181 182 183 184 185 186
void AnalysisConfig::SetMkldnnCacheCapacity(int capacity) {
#ifdef PADDLE_WITH_MKLDNN
  mkldnn_cache_capacity_ = capacity;
#else
  LOG(ERROR) << "Please compile with MKLDNN first to set MKLDNN Thread Id";
  mkldnn_cache_capacity_ = 0;
#endif
}

187 188 189 190 191 192 193 194 195 196 197 198 199
void AnalysisConfig::EnableMkldnnQuantizer() {
#ifdef PADDLE_WITH_MKLDNN
  if (!mkldnn_quantizer_config_)
    mkldnn_quantizer_config_.reset(new MkldnnQuantizerConfig());
  use_mkldnn_quantizer_ = true;
#else
  LOG(ERROR) << "Please compile with MKLDNN first to use MkldnnQuantizer";
  use_mkldnn_quantizer_ = false;
#endif

  Update();
}

M
mozga-intel 已提交
200 201 202 203 204 205 206 207 208 209
void AnalysisConfig::EnableNgraph() {
#ifdef PADDLE_WITH_NGRAPH
  pass_builder()->EnableNgraph();
  use_ngraph_ = true;
#else
  LOG(ERROR) << "Please compile with NGRAPH first to use NGRAPH";
  use_ngraph_ = false;
#endif
}

210
MkldnnQuantizerConfig *AnalysisConfig::mkldnn_quantizer_config() const {
211 212
  PADDLE_ENFORCE_NOT_NULL(mkldnn_quantizer_config_,
                          "MkldnnQuantizer was not enabled yet.");
213
  return mkldnn_quantizer_config_.get();
214 215
}

216
void AnalysisConfig::EnableTensorRtEngine(
N
nhzlx 已提交
217
    int workspace_size, int max_batch_size, int min_subgraph_size,
218 219
    AnalysisConfig::Precision precision_mode, bool use_static,
    bool use_calib_mode) {
Y
Yan Chunwei 已提交
220 221 222 223 224 225
#ifdef PADDLE_WITH_CUDA
  if (!use_gpu()) {
    LOG(ERROR) << "To use TensorRT engine, please call EnableGpu() first";
    return;
  }

226 227 228
  use_tensorrt_ = true;
  tensorrt_workspace_size_ = workspace_size;
  tensorrt_max_batchsize_ = max_batch_size;
N
nhzlx 已提交
229
  tensorrt_min_subgraph_size_ = min_subgraph_size;
N
nhzlx 已提交
230
  tensorrt_precision_mode_ = precision_mode;
N
nhzlx 已提交
231
  trt_use_static_engine_ = use_static;
232
  trt_use_calib_mode_ = use_calib_mode;
Y
Yan Chunwei 已提交
233

234
  Update();
Y
Yan Chunwei 已提交
235 236 237 238
#else
  LOG(ERROR)
      << "To use TensorRT engine, please compile inference lib with GPU first.";
#endif
239 240
}

Y
Yan Chunwei 已提交
241
// TODO(Superjomn) refactor this, buggy.
242
void AnalysisConfig::Update() {
243 244 245
  auto info = SerializeInfoCache();
  if (info == serialized_info_cache_) return;

Y
Yan Chunwei 已提交
246 247 248 249 250 251 252 253 254 255 256 257
  // Transfer pass_builder and copy the existing compatible passes.
  if (!pass_builder_ || ((use_gpu() ^ pass_builder_->use_gpu()))) {
    if (use_gpu()) {
      pass_builder_.reset(new GpuPassStrategy);

      if (use_tensorrt_) {
        // Append after the Affine_channel_conv_fuse pass.
        pass_builder()->InsertPass(3, "tensorrt_subgraph_pass");
      }
    } else {
      pass_builder_.reset(new CpuPassStrategy);
    }
258
  } else {
Y
Yan Chunwei 已提交
259 260 261 262 263 264 265 266
    if (use_gpu()) {
      pass_builder_.reset(new GpuPassStrategy(
          *static_cast<GpuPassStrategy *>(pass_builder_.get())));

    } else {
      pass_builder_.reset(new CpuPassStrategy(
          *static_cast<CpuPassStrategy *>(pass_builder_.get())));
    }
267 268 269
  }

  if (use_tensorrt_) {
270 271 272
    pass_builder()->ClearPasses();
    for (const auto &pass : kTRTSubgraphPasses) {
      pass_builder()->AppendPass(pass);
273 274 275
    }
  }

276 277 278 279 280 281 282 283 284 285
  if (use_gpu() && use_cudnn_) {
#ifdef PADDLE_WITH_CUDA
    if (!enable_ir_optim_) {
      LOG(ERROR) << "EnableCUDNN() only works when IR optimization is enabled.";
    } else {
      pass_builder()->EnableCUDNN();
    }
#endif
  }

M
mozga-intel 已提交
286 287 288 289 290 291 292 293 294 295 296 297 298 299
  if (use_ngraph_) {
    if (!enable_ir_optim_) {
      LOG(ERROR)
          << "EnableNgraph() only works when IR optimization is enabled.";
    }
#ifdef PADDLE_WITH_NGRAPH
    pass_builder()->EnableNgraph();
    use_ngraph_ = true;
#else
    LOG(ERROR) << "Please compile with NGRAPH first to use NGRAPH";
    use_ngraph_ = false;
#endif
  }

300
  if (use_mkldnn_) {
W
Wojciech Uss 已提交
301
#ifdef PADDLE_WITH_MKLDNN
302 303 304
    if (!enable_ir_optim_) {
      LOG(ERROR)
          << "EnableMKLDNN() only works when IR optimization is enabled.";
W
Wojciech Uss 已提交
305 306
    } else {
      pass_builder()->EnableMKLDNN();
307 308 309 310
    }
#endif
  }

311 312 313 314 315
  // Quantization passes must come after all other optimization passes
  if (use_mkldnn_quantizer_) {
    if (!enable_ir_optim_) {
      LOG(ERROR) << "EnableMkldnnQuantizer() only works when IR optimization "
                    "is enabled.";
316 317
    }
#ifdef PADDLE_WITH_MKLDNN
318
    pass_builder()->EnableMkldnnQuantizer();
319 320 321
#endif
  }

322 323 324 325
#ifdef PADDLE_WITH_MKLDNN
  // Do not optimize before quantization
  if (enable_memory_optim_ && !use_mkldnn_quantizer_) {
#else
Y
Yan Chunwei 已提交
326
  if (enable_memory_optim_) {
327 328
#endif
    pass_builder()->AppendAnalysisPass("memory_optimize_pass");
Y
Yan Chunwei 已提交
329 330
  }

331 332 333 334
  if (use_anakin_) {
    PADDLE_ENFORCE(!use_tensorrt_,
                   "Anakin sub-graph and TensorRT sub-graph are not allowed to "
                   "run at the same time!");
335 336 337 338 339
    if (use_gpu_) {
      LOG(INFO) << "Run Anakin GPU mode";
    } else {
      LOG(INFO) << "Run Anakin CPU mode";
    }
340 341 342

    pass_builder()->ClearPasses();
    for (const auto &pass : kAnakinSubgraphPasses) {
343 344 345 346
      if (std::find(anakin_passes_filter_.begin(), anakin_passes_filter_.end(),
                    pass) == anakin_passes_filter_.end()) {
        pass_builder()->AppendPass(pass);
      }
347
    }
Y
Yan Chunwei 已提交
348 349
  }

350 351 352 353 354
  if (ir_debug_) {
    pass_builder()->TurnOnDebug();
  }
}

355
std::string AnalysisConfig::SerializeInfoCache() {
356
  std::stringstream ss;
Y
Yan Chunwei 已提交
357 358 359 360
  ss << model_dir_;
  ss << prog_file_;
  ss << params_file_;

361
  ss << use_gpu_;
Y
Yan Chunwei 已提交
362
  ss << device_id_;
363 364 365 366 367
  ss << memory_pool_init_size_mb_;

  ss << use_tensorrt_;
  ss << tensorrt_workspace_size_;
  ss << tensorrt_max_batchsize_;
Y
Yan Chunwei 已提交
368 369 370
  ss << tensorrt_min_subgraph_size_;

  ss << enable_memory_optim_;
Y
Yan Chunwei 已提交
371 372
  ss << static_memory_optim_;
  ss << static_memory_optim_force_update_;
373

M
mozga-intel 已提交
374 375
  ss << use_ngraph_;

376
  ss << use_mkldnn_;
377
  ss << mkldnn_cache_capacity_;
Y
Yan Chunwei 已提交
378 379 380
  for (auto &item : mkldnn_enabled_op_types_) ss << item;
  ss << ";";

381
  ss << use_mkldnn_quantizer_;
Y
Yan Chunwei 已提交
382 383
  ss << model_from_memory_;

384 385 386 387
  ss << enable_ir_optim_;
  ss << use_feed_fetch_ops_;
  ss << ir_debug_;

Y
Yan Chunwei 已提交
388 389
  ss << specify_input_name_;
  ss << cpu_math_library_num_threads_;
390
  ss << use_anakin_;
391
  ss << anakin_min_subgraph_size_;
392 393 394
  return ss.str();
}

395
void AnalysisConfig::SetCpuMathLibraryNumThreads(
396 397
    int cpu_math_library_num_threads) {
  cpu_math_library_num_threads_ = cpu_math_library_num_threads;
Y
Yan Chunwei 已提交
398 399

  Update();
400 401
}

402
float AnalysisConfig::fraction_of_gpu_memory_for_pool() const {
403 404 405 406
#ifdef PADDLE_WITH_CUDA
  // Get the GPU memory details and calculate the fraction of memory for the
  // GPU memory pool.
  size_t gpu_used, gpu_available;
407
  platform::SetDeviceId(device_id_);
408 409 410 411 412 413 414 415
  platform::GpuMemoryUsage(&gpu_used, &gpu_available);
  double total_gpu_memory = (gpu_used + gpu_available) / 1024. / 1024.;
  float fraction_of_gpu_memory =
      static_cast<double>(memory_pool_init_size_mb()) / total_gpu_memory;
  return fraction_of_gpu_memory;
#else
  return 0.;
#endif
416 417
}

418 419
void AnalysisConfig::EnableMemoryOptim(bool static_optim,
                                       bool force_update_static_cache) {
Y
Yan Chunwei 已提交
420
  enable_memory_optim_ = true;
Y
Yan Chunwei 已提交
421 422
  static_memory_optim_ = static_optim;
  static_memory_optim_force_update_ = force_update_static_cache;
Y
Yan Chunwei 已提交
423 424 425 426

  Update();
}

427
bool AnalysisConfig::enable_memory_optim() const {
Y
Yan Chunwei 已提交
428 429 430
  return enable_memory_optim_;
}

431 432 433 434
void AnalysisConfig::SetModelBuffer(const char *prog_buffer,
                                    size_t prog_buffer_size,
                                    const char *param_buffer,
                                    size_t param_buffer_size) {
435 436
  prog_file_ = std::string(prog_buffer, prog_buffer + prog_buffer_size);
  params_file_ = std::string(param_buffer, param_buffer + param_buffer_size);
T
Tao Luo 已提交
437
  model_from_memory_ = true;
Y
Yan Chunwei 已提交
438 439

  Update();
T
Tao Luo 已提交
440 441
}

442
NativeConfig AnalysisConfig::ToNativeConfig() const {
Y
Yan Chunwei 已提交
443 444 445 446 447 448 449 450 451 452 453
  NativeConfig config;
  config.model_dir = model_dir_;
  config.prog_file = prog_file_;
  config.param_file = params_file_;
  config.use_gpu = use_gpu_;
  config.device = device_id_;
  config.fraction_of_gpu_memory = fraction_of_gpu_memory_for_pool();
  config.specify_input_name = specify_input_name_;
  return config;
}

Y
Yan Chunwei 已提交
454 455 456 457
void AnalysisConfig::SwitchIrDebug(int x) {
  ir_debug_ = x;
  Update();
}
458
void AnalysisConfig::EnableAnakinEngine(
459
    int max_batch_size, std::map<std::string, std::vector<int>> max_input_shape,
460 461 462
    int min_subgraph_size, AnalysisConfig::Precision precision_mode,
    bool auto_config_layout, std::vector<std::string> passes_filter,
    std::vector<std::string> ops_filter) {
463
  anakin_max_batchsize_ = max_batch_size;
464
  anakin_max_input_shape_ = max_input_shape;
465
  anakin_min_subgraph_size_ = min_subgraph_size;
466 467
  anakin_passes_filter_ = passes_filter;
  anakin_ops_filter_ = ops_filter;
468
  use_anakin_ = true;
469 470
  anakin_precision_mode_ = precision_mode;
  anakin_auto_config_layout_ = auto_config_layout;
471 472
  Update();
}
473 474 475 476 477 478 479 480

void AnalysisConfig::PartiallyRelease() {
  prog_file_.clear();
  prog_file_.shrink_to_fit();
  params_file_.clear();
  params_file_.shrink_to_fit();
}

481
}  // namespace paddle