tracer.cc 15.4 KB
Newer Older
J
Jiabin Yang 已提交
1
// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14
//
// 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/imperative/tracer.h"
15
#include <map>
H
hong 已提交
16
#include <set>
M
minqiyang 已提交
17
#include <unordered_set>
18
#include <utility>
19
#include "paddle/fluid/framework/op_registry.h"
20
#include "paddle/fluid/imperative/amp_auto_cast.h"
21
#include "paddle/fluid/imperative/op_base.h"
22
#include "paddle/fluid/platform/denormal.h"
23
#include "paddle/fluid/platform/device/device_wrapper.h"
C
chengduo 已提交
24
#include "paddle/fluid/platform/profiler.h"
25
#include "paddle/fluid/platform/profiler/event_tracing.h"
26 27
#include "paddle/fluid/string/string_helper.h"

28
DECLARE_bool(use_mkldnn);
29 30
DECLARE_string(tracer_mkldnn_ops_on);
DECLARE_string(tracer_mkldnn_ops_off);
31

32
namespace paddle {
M
minqiyang 已提交
33 34
namespace imperative {

35 36
thread_local bool Tracer::enable_program_desc_tracing_ = false;

Z
Zeng Jinle 已提交
37 38
thread_local bool Tracer::has_grad_ = true;

39 40
thread_local AmpLevel Tracer::amp_level_ = AmpLevel::O0;

41
thread_local phi::DataType Tracer::amp_dtype_ = phi::DataType::FLOAT32;
42

43 44 45 46 47 48 49 50 51
static std::shared_ptr<Tracer> g_current_tracer(nullptr);

const std::shared_ptr<Tracer>& GetCurrentTracer() { return g_current_tracer; }

void SetCurrentTracer(const std::shared_ptr<Tracer>& tracer) {
  g_current_tracer = tracer;
  VLOG(6) << "Set current tracer: " << g_current_tracer;
}

52
void PassStopGradient(const NameVarBaseMap& outs, bool generate_grad) {
53 54 55 56 57 58 59 60 61 62 63 64
  for (const auto& pair : outs) {
    for (const auto& var : pair.second) {
      // NOTE(zhiqiu): this happends when None output are passed from python
      // side. For example, fake_quantize_dequantize_moving_average_abs_max may
      // pass None OutAccum in eval mode.
      // It can be refined by generate several different pybind interface for
      // one operator with different function signature.
      if (var == nullptr) {
        VLOG(4) << pair.first << " is NULL";
        continue;
      }
      VLOG(6) << "Set output: " << var->Name() << "'s OverridedStopGradient as "
65
              << generate_grad;
66
      var->InnerSetOverridedStopGradient(generate_grad);
67 68 69 70
    }
  }
}

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
void IncreaseVarbaseReferenceCountUntilCopyComplete(
    const std::shared_ptr<imperative::VarBase>& var,
    const platform::Place& place) {
  // Note(zhiqiu): Follow the logic of TensorCopy to determine the place that we
  // need to add callback, see tensor_utils.cc:245
  auto place_ = platform::is_gpu_place(place) ? place : var->Place();

  auto tracer = imperative::GetCurrentTracer();
  auto gc = tracer->MutableGarbageCollectorIfNotExists(place_);

  // Note(zhiqiu): This is an empty callback, the only way is to "reference"
  // var, so it will not be destructed until the kernels launched at current
  // stream of given place is finished.
  auto callback = [var, place_]() {
    VLOG(4) << "Run callback of var:" << var->Name() << " at place " << place_;
  };

  gc->DirectClearCallback(callback);
}

paddle::framework::GarbageCollector* Tracer::MutableGarbageCollectorIfNotExists(
    const platform::Place& place) {
  // if not exists, create a new GarbageCollector at given place
  if (gcs_.count(place) == 0) {
    std::unique_ptr<framework::GarbageCollector> gc;
    if (platform::is_gpu_place(place)) {
Z
zhulei 已提交
97
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
98
      gc.reset(new framework::DefaultStreamGarbageCollector(place, 0));
99 100 101 102 103 104 105 106

      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use CUDA device since it's not compiled with CUDA,"
          "Please recompile or reinstall Paddle with GPU support."));
#endif
    } else if (platform::is_cuda_pinned_place(place)) {
Z
zhulei 已提交
107
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
108
      gc.reset(new framework::CUDAPinnedGarbageCollector(place, 0));
109 110 111 112 113 114 115 116 117 118

      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use CUDAPinned device since it's not compiled with "
          "CUDA,"
          "Please recompile or reinstall Paddle with GPU support."));
#endif
    } else if (platform::is_xpu_place(place)) {
#if defined(PADDLE_WITH_XPU)
119
      gc.reset(new framework::XPUGarbageCollector(place, 0));
120 121 122 123 124 125 126
      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use XPU device since it's not compiled with XPU,"
          "Please recompile or reinstall Paddle with XPU support."));
#endif
    } else if (platform::is_cpu_place(place)) {
127
      gc.reset(new framework::CPUGarbageCollector(place, 0));
128
      VLOG(10) << "Created GarbageCollector at " << place;
129 130 131
    } else if (platform::is_npu_place(place)) {
#if defined(PADDLE_WITH_ASCEND_CL)
      // TODO(zhiqiu): fix bugs and enable NPUDefaultStreamGarbageCollector.
132
      gc.reset(new framework::NPUUnsafeFastGarbageCollector(place, 0));
133 134 135 136 137
      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use NPU device since it's not compiled with NPU,"
          "Please recompile or reinstall Paddle with NPU support."));
F
fwenguang 已提交
138 139 140
#endif
    } else if (platform::is_mlu_place(place)) {
#if defined(PADDLE_WITH_MLU)
141
      gc.reset(new framework::MLUDefaultStreamGarbageCollector(place, 0));
F
fwenguang 已提交
142 143 144 145 146
      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use MLU device since it's not compiled with MLU,"
          "Please recompile or reinstall Paddle with MLU support."));
147 148 149 150 151 152 153 154 155 156 157
#endif
    } else if (platform::is_custom_place(place)) {
#if defined(PADDLE_WITH_CUSTOM_DEVICE)
      gc.reset(new framework::CustomDefaultStreamGarbageCollector(place, 0));
      VLOG(10) << "Created GarbageCollector at " << place;
#else
      PADDLE_THROW(platform::errors::PermissionDenied(
          "Paddle can't use CustomDevice since it's not compiled with "
          "CustomDevice,"
          "Please recompile or reinstall Paddle with CustomDevice "
          "support."));
158
#endif
159 160 161 162 163 164 165 166 167 168
    } else {
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "Unsupported place for garbage collection"));
    }
    gcs_.emplace(place, std::move(gc));
  }

  return gcs_.at(place).get();
}

J
Jiabin Yang 已提交
169 170 171 172
template <typename VarType>
void Tracer::TraceOp(const std::string& type, const NameVarMap<VarType>& ins,
                     const NameVarMap<VarType>& outs,
                     framework::AttributeMap attrs,
173
                     const platform::Place& place, bool trace_backward,
J
Jiabin Yang 已提交
174 175
                     const std::map<std::string, std::string>& inplace_map,
                     paddle::framework::AttributeMap* passed_default_attrs_,
176
                     bool use_default_attr_map) {
177 178
  platform::RecordEvent op_type_record_event(
      type, platform::TracerEventType::Operator, 2);
179
  platform::ScopedFlushDenormal flush;
J
Jiabin Yang 已提交
180
  VLOG(1) << "Trace Op: " << type;
181
  if (FLAGS_use_mkldnn) {
182 183 184 185 186 187 188 189 190 191 192
    // if both lists are empty all ops are enabled (default for
    // FLAGS_use_mkldnn=1)
    // if ops_on list is not empty only ops from that list are enabled
    if (!FLAGS_tracer_mkldnn_ops_on.empty()) {
      auto is_on = FLAGS_tracer_mkldnn_ops_on.find(type) != std::string::npos;
      attrs["use_mkldnn"] = is_on;
    } else {
      // if ops_on list is empty all ops are enabled except types from off_list
      auto is_off = FLAGS_tracer_mkldnn_ops_off.find(type) != std::string::npos;
      attrs["use_mkldnn"] = !is_off;
    }
193
  }
194 195 196 197
  auto op = framework::OpRegistry::CreateOp(type, {}, {}, {}, false);
  const auto& op_info = op->Info();
  auto* attr_checker = op_info.Checker();
  if (attr_checker) {
198
    attr_checker->Check(&attrs, true, /*only_check_exist_value=*/true);
199 200
  }

201 202 203 204 205
  static paddle::framework::AttributeMap empty_attrs_map = {};
  const paddle::framework::AttributeMap& default_attrs =
      attr_checker == nullptr ? empty_attrs_map
                              : attr_checker->GetDefaultAttrMap();

J
Jiabin Yang 已提交
206
  NameVarMap<VarType> new_ins = ins;
L
Leo Chen 已提交
207
  if (amp_level_ == AmpLevel::O1) {
208
    VLOG(5) << "Auto mixed precision run operator: " << type;
209
    if (amp_dtype_ == phi::DataType::FLOAT16) {
210
      new_ins = AutoCastInputs<VarType>(type, ins);
211
    } else if (amp_dtype_ == phi::DataType::BFLOAT16) {
212 213
      new_ins = AutoCastBF16Inputs<VarType>(type, ins);
    }
L
Leo Chen 已提交
214
  } else if (amp_level_ == AmpLevel::O2) {
215
    VLOG(5) << "Pure fp16 run operator: " << type;
216
    if (amp_dtype_ == phi::DataType::FLOAT16) {
217
      new_ins = CastPureFp16Inputs<VarType>(type, ins);
218
    } else if (amp_dtype_ == phi::DataType::BFLOAT16) {
219 220
      new_ins = CastPureBf16Inputs<VarType>(type, ins);
    }
221 222
  }

223
  try {
224 225
    if (platform::is_gpu_place(place)) {
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
226
      platform::SetDeviceId(place.device);
227 228 229 230 231 232
#else
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "PaddlePaddle should compile with GPU if use CUDAPlace."));
#endif
    } else if (platform::is_xpu_place(place)) {
#ifdef PADDLE_WITH_XPU
233
      platform::SetXPUDeviceId(place.device);
234 235 236
#else
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "PaddlePaddle should compile with XPU if use XPUPlace."));
H
houj04 已提交
237 238 239
#endif
    } else if (platform::is_npu_place(place)) {
#ifdef PADDLE_WITH_ASCEND_CL
240
      platform::SetNPUDeviceId(place.device);
H
houj04 已提交
241 242 243
#else
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "PaddlePaddle should compile with NPU if use NPUPlace."));
F
fwenguang 已提交
244 245 246
#endif
    } else if (platform::is_mlu_place(place)) {
#ifdef PADDLE_WITH_MLU
247
      platform::SetMLUDeviceId(place.device);
F
fwenguang 已提交
248 249 250
#else
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "PaddlePaddle should compile with MLU if use MLUPlace."));
251 252 253 254 255 256 257 258
#endif
    } else if (platform::is_custom_place(place)) {
#ifdef PADDLE_WITH_CUSTOM_DEVICE
      platform::DeviceManager::SetDevice(place);
#else
      PADDLE_THROW(platform::errors::PreconditionNotMet(
          "PaddlePaddle should compile with CustomDevice if use "
          "CustomPlace."));
259 260
#endif
    }
261
    if (!use_default_attr_map) {
J
Jiabin Yang 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274
      PADDLE_ENFORCE_NOT_NULL(passed_default_attrs_,
                              paddle::platform::errors::PermissionDenied(
                                  "Detected default_attrs = nullptr."));
      VLOG(6) << "Use passed in default attrs";
      OpBase::Run(*op, new_ins, outs, attrs, (*passed_default_attrs_), place);
    } else {
      VLOG(6) << "Use Checker's default attrs";
      if (passed_default_attrs_) {
        // TODO(jiabin): Update this without copy
        *passed_default_attrs_ = default_attrs;
      }
      OpBase::Run(*op, new_ins, outs, attrs, default_attrs, place);
    }
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
  } catch (platform::EnforceNotMet& exception) {
    framework::AppendErrorOpHint(type, &exception);
    throw std::move(exception);
  } catch (std::exception& ex) {
    PADDLE_THROW(platform::errors::Fatal(
        "Operator %s raises an %s exception.\n"
        "The exception content is\n:%s.",
        type, platform::demangle(typeid(ex).name()), ex.what()));
  } catch (...) {
    // NOTE: this branch represents a very serious bug with
    // low probability of occurrence, and we can't get its
    // exception content here.
    PADDLE_THROW(platform::errors::Fatal(
        "Operator %s raises an unknown exception.", type));
  }
J
Jiabin Yang 已提交
290

291 292
  if (enable_program_desc_tracing_) {
    VLOG(5) << "Trace op " << type << " into ProgramDesc";
293
    program_desc_tracer_->InsertOp(type, new_ins, outs, attrs);
294 295
  }

296
  if (ComputeRequiredGrad(new_ins, outs, trace_backward)) {
297 298 299 300 301 302 303 304
    PADDLE_ENFORCE_EQ(
        passed_default_attrs_, nullptr,
        paddle::platform::errors::PermissionDenied(
            "We expect passed_default_attrs_ is nullptr while "
            "use_default_attr_map is true, however we got not null "
            "passed_default_attrs_. Please check your usage of trace_op. "));
    CreateGradOpNode(*op, new_ins, outs, attrs, default_attrs, place,
                     inplace_map);
305 306
  } else {
    VLOG(3) << "No Grad to track for Op: " << type;
307
  }
J
Jiabin Yang 已提交
308
  VLOG(6) << "Finish Trace Op: " << type;
M
minqiyang 已提交
309 310
}

J
Jiabin Yang 已提交
311 312 313 314 315
template void Tracer::TraceOp<VarBase>(
    const std::string& type, const NameVarMap<VarBase>& ins,
    const NameVarMap<VarBase>& outs, framework::AttributeMap attrs,
    const platform::Place& place, bool trace_backward,
    const std::map<std::string, std::string>& inplace_map,
316
    paddle::framework::AttributeMap* default_attrs, bool use_default_attr_map);
J
Jiabin Yang 已提交
317

318 319 320
template void Tracer::TraceOp<egr::EagerVariable>(
    const std::string& type, const NameVarMap<egr::EagerVariable>& ins,
    const NameVarMap<egr::EagerVariable>& outs, framework::AttributeMap attrs,
J
Jiabin Yang 已提交
321 322
    const platform::Place& place, bool trace_backward,
    const std::map<std::string, std::string>& inplace_map_,
323
    paddle::framework::AttributeMap* default_attrs, bool use_default_attr_map);
J
Jiabin Yang 已提交
324

325
void Tracer::TraceOp(const std::string& type, const NameVarBaseMap& ins,
326 327
                     const NameVarBaseMap& outs, framework::AttributeMap attrs,
                     const std::map<std::string, std::string>& inplace_map) {
J
Jiabin Yang 已提交
328 329 330 331 332 333 334 335 336
  TraceOp<VarBase>(type, ins, outs, std::move(attrs), expected_place_,
                   has_grad_, inplace_map);
}

void Tracer::TraceOp(const std::string& type, const NameTensorMap& ins,
                     const NameTensorMap& outs,
                     paddle::framework::AttributeMap attrs,
                     const paddle::platform::Place& place,
                     paddle::framework::AttributeMap* default_attrs,
337
                     bool use_default_attr_map,
J
Jiabin Yang 已提交
338
                     const std::map<std::string, std::string>& inplace_map) {
339 340 341 342
  VLOG(6) << "Running On Eager TraceOp with use_default_attr_map: "
          << use_default_attr_map;
  TraceOp<egr::EagerVariable>(type, ins, outs, std::move(attrs), place, false,
                              inplace_map, default_attrs, use_default_attr_map);
J
Jiabin Yang 已提交
343 344 345 346 347 348 349
}

void Tracer::TraceOp(const std::string& type, const NameTensorMap& ins,
                     const NameTensorMap& outs,
                     paddle::framework::AttributeMap attrs,
                     const std::map<std::string, std::string>& inplace_map) {
  VLOG(6) << "Running On Eager TraceOp(less): ";
350 351 352
  TraceOp<egr::EagerVariable>(type, ins, outs, std::move(attrs),
                              expected_place_, false, inplace_map, nullptr,
                              true);
353 354
}

W
WangXi 已提交
355 356 357 358
void Tracer::SetExpectedPlace(platform::Place place) {
  expected_place_ = place;
}

J
Jiabin Yang 已提交
359
bool Tracer::ComputeRequiredGrad(const NameVarBaseMap& ins,
360
                                 const NameVarBaseMap& outs,
J
Jiabin Yang 已提交
361
                                 bool trace_backward) {
362 363 364 365 366 367 368 369 370 371 372 373 374
  if (!trace_backward) return false;

  for (const auto& name_pair : ins) {
    for (const auto& var_base : name_pair.second) {
      if (!var_base->OverridedStopGradient()) {
        VLOG(6) << "Find out input: " << var_base->Name()
                << "'s GeneratedGrad is True";
        PassStopGradient(outs, var_base->OverridedStopGradient());
        return true;
      }
    }
  }
  return false;
M
minqiyang 已提交
375 376
}

J
Jiabin Yang 已提交
377 378 379 380 381 382
bool Tracer::ComputeRequiredGrad(const NameTensorMap& ins,
                                 const NameTensorMap& outs,
                                 bool trace_backward) {
  return false;
}

M
minqiyang 已提交
383
}  // namespace imperative
384
}  // namespace paddle