Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into eager_dygraph_codegen_debug

Author: jim19930609

cmake/external/cinn.cmake

@@ -26,8 +26,7 @@ add_definitions(-w)
 ######################################
 include(ExternalProject)
 set(CINN_PREFIX_DIR ${THIRD_PARTY_PATH}/CINN)
-# TODO(zhhsplendid): Modify git tag after we have release tag
-set(CINN_GIT_TAG develop)
+set(CINN_GIT_TAG release/v0.1)
 set(CINN_OPTIONAL_ARGS -DPY_VERSION=${PY_VERSION}
  -DWITH_CUDA=${WITH_GPU}
  -DWITH_CUDNN=${WITH_GPU}

paddle/fluid/distributed/fleet_executor/compute_interceptor.cc

@@ -64,7 +64,7 @@ void ComputeInterceptor::IncreaseReady(int64_t up_id) {
 
  // source node has no upstream, data_is_ready is send by carrier or others
  if (is_source_ && up_id == -1) {
- it->second.second = GetTaskNode()->max_run_times();
+ it->second.second += GetTaskNode()->max_run_times();
  return;
  }
 
@@ -121,16 +121,6 @@ bool ComputeInterceptor::CanWriteOutput() {
  return true;
 }
 
-// only source node need reset
-bool ComputeInterceptor::ShouldReset() {
- if (is_source_ && step_ == node_->max_run_times()) {
- VLOG(3) << "Interceptor " << GetInterceptorId()
- << " should reset for step: " << step_ << ".";
- return true;
- }
- return false;
-}
-
 void ComputeInterceptor::SendDataReadyToDownStream() {
  for (auto& outs : out_buffs_) {
  auto down_id = outs.first;
@@ -186,24 +176,7 @@ void ComputeInterceptor::RunOps() {
 }
 
 void ComputeInterceptor::Run() {
- // If there is no limit, source interceptor can be executed
- // an unlimited number of times.
- // Now source node can only run max_run_times.
- if (ShouldReset()) {
- for (auto& out_buff : out_buffs_) {
- // buffer is using
- if (out_buff.second.second != 0) {
- VLOG(3) << "Interceptor " << GetInterceptorId()
- << " out buffer for downstream: " << out_buff.first
- << "'s counter is: " << out_buff.second.second
- << ". Cannot be reset.";
- return;
- }
- }
- step_ = 0; // reset
- }
-
- while (IsInputReady() && CanWriteOutput() && !ShouldReset()) {
+ while (IsInputReady() && CanWriteOutput()) {
  VLOG(3) << "id=" << GetInterceptorId() << " ComputeInterceptor running";
 
  RunOps();

paddle/fluid/distributed/fleet_executor/compute_interceptor.h

@@ -39,7 +39,6 @@ class ComputeInterceptor : public Interceptor {
  void DecreaseBuff(int64_t down_id);
  bool IsInputReady();
  bool CanWriteOutput();
- bool ShouldReset();
 
  void Run();
  void Compute(const InterceptorMessage& msg);

paddle/fluid/distributed/service/heter_server.h

@@ -336,7 +336,7 @@ class HeterServer {
 
  bool IsExit() { return service_.IsExit(); }
 
- HeterServer() { this->ready_ = 0; }
+ HeterServer() : service_(), ready_(0) {}
 
  void RegisterServiceHandler(std::string message_name,
  HeterServiceHandler func);
@@ -391,7 +391,7 @@ class HeterServer {
  DISABLE_COPY_AND_ASSIGN(HeterServer);
  std::mutex mutex_ready_;
 
- int ready_ = 0;
+ int ready_;
 };
 
 } // end namespace distributed

paddle/fluid/eager/auto_code_generator/eager_generator.cc

@@ -39,6 +39,12 @@ static std::unordered_set<std::string> operators_to_skip = {
 static std::unordered_set<std::string> operators_to_codegen = {};
 static std::unordered_set<std::string> skipped_operators = {};
 
+static std::string LegalizeVariableName(const std::string& var_name) {
+ std::string ret = var_name;
+ std::replace(ret.begin(), ret.end(), '-', '_'); // replace all '-' to '_'
+ return ret;
+}
+
 static std::string AttrTypeToString(const proto::AttrType& type) {
  std::string ret;
  switch (type) {
@@ -1053,24 +1059,25 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  const std::string& output_name = output.name();
  std::string out_tensor_str;
  size_t return_position = fwd_outputs_name_pos_map.at(output_name);
+ std::string output_varname = LegalizeVariableName(output_name);
 
  if (output.duplicable()) {
  const char* FWD_OUT_TENSORS_TEMPLATE =
  " std::vector<egr::EagerTensor> %s = "
  "egr::EagerUtils::GetOutputs(outs[\"%s\"]);\n";
  out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSORS_TEMPLATE,
- output_name, output_name);
+ output_varname, output_name);
  return_types[return_position] = "std::vector<egr::EagerTensor>";
  } else {
  const char* FWD_OUT_TENSOR_TEMPLATE =
  " egr::EagerTensor %s = "
  "egr::EagerUtils::GetOutput(outs[\"%s\"][0]);\n";
  out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSOR_TEMPLATE,
- output_name, output_name);
+ output_varname, output_name);
  return_types[return_position] = "egr::EagerTensor";
  }
 
- return_contents[return_position] = output_name;
+ return_contents[return_position] = output_varname;
  generated_function_body += out_tensor_str;
  }
  generated_function_body += "\n";

paddle/fluid/eager/auto_code_generator/op_list.txt

@@ -237,7 +237,6 @@ spp
 floor
 gelu
 retinanet_detection_output
-minus
 push_dense
 silu
 sequence_erase

paddle/fluid/framework/garbage_collector.cc

@@ -53,6 +53,15 @@ void XPUGarbageCollector::ClearCallback(const std::function<void()> &callback) {
 }
 #endif
 
+#ifdef PADDLE_WITH_IPU
+IPUGarbageCollector::IPUGarbageCollector(const platform::IPUPlace &place,
+ size_t max_memory_size)
+ : GarbageCollector(place, max_memory_size) {}
+void IPUGarbageCollector::ClearCallback(const std::function<void()> &callback) {
+ callback();
+}
+#endif
+
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
 UnsafeFastGPUGarbageCollector::UnsafeFastGPUGarbageCollector(
  const platform::CUDAPlace &place, size_t max_memory_size)

paddle/fluid/framework/garbage_collector.h

@@ -80,6 +80,16 @@ class XPUGarbageCollector : public GarbageCollector {
 };
 #endif
 
+#ifdef PADDLE_WITH_IPU
+class IPUGarbageCollector : public GarbageCollector {
+ public:
+ IPUGarbageCollector(const platform::IPUPlace &place, size_t max_memory_size);
+
+ protected:
+ void ClearCallback(const std::function<void()> &callback) override;
+};
+#endif
+
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
 class UnsafeFastGPUGarbageCollector : public GarbageCollector {
  public:

paddle/fluid/framework/heter_pipeline_trainer_test.cc

@@ -115,8 +115,6 @@ TEST(HeterPipelineTrainerTest, GPU) {
  t3.add_trainers(1);
  t3.add_trainers(1);
  t3.add_trainers(1);
- t3.add_dump_fields("hello");
- t3.add_dump_param("fc_0");
  auto* heter_section_param3 = t3.mutable_heter_section_param();
  heter_section_param3->set_num_pipeline_stages(3);
  heter_section_param3->set_pipeline_stage(2);

paddle/fluid/framework/heter_section_worker.cc

@@ -277,7 +277,7 @@ void HeterSectionWorker::CopyParameters(int microbatch_id,
 void HeterSectionWorker::Run() {
  if (debug_) {
  size_t total_ops_size = forward_ops_.size() + backward_ops_.size();
- op_name_.resize(total_ops_size);
+ op_name_.reserve(total_ops_size);
  op_total_time_.resize(total_ops_size);
  platform::SetNumThreads(1);
  // forward op + backward op