fleet_executor.cc 5.5 KB
Newer Older
L
LiYuRio 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// Copyright (c) 2021 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/distributed/fleet_executor/fleet_executor.h"
16
#include "paddle/fluid/distributed/fleet_executor/global.h"
17
#include "paddle/fluid/distributed/fleet_executor/message_bus.h"
L
LiYuRio 已提交
18
#include "paddle/fluid/distributed/fleet_executor/runtime_graph.h"
19
#include "paddle/fluid/distributed/fleet_executor/task_node.h"
20 21 22
#include "paddle/fluid/framework/executor_gc_helper.h"
#include "paddle/fluid/framework/op_desc.h"
#include "paddle/fluid/framework/op_registry.h"
23
#include "paddle/fluid/framework/operator.h"
L
LiYuRio 已提交
24 25 26 27 28 29
#include "paddle/fluid/framework/program_desc.h"

namespace paddle {
namespace distributed {

FleetExecutor::FleetExecutor(const std::string& exe_desc_str) {
L
LiYuRio 已提交
30 31 32
  bool parse_flag = exe_desc_.ParseFromString(exe_desc_str);
  PADDLE_ENFORCE(parse_flag, platform::errors::PreconditionNotMet(
                                 "Error occurs while parsing string to proto"));
33 34 35
  // Message bus will be created and inited only once
  GlobalVal<MessageBus>::Create();
  InitMessageBus();
L
LiYuRio 已提交
36 37
}

38
FleetExecutor::~FleetExecutor() {
39 40
  for (const auto& carrier_id : carrier_ids_) {
    GlobalMap<std::string, Carrier>::Get(carrier_id)->Release();
41
  }
42
}
L
LiYuRio 已提交
43

44
void FleetExecutor::Init(
45 46
    const std::string& carrier_id, const framework::ProgramDesc& program_desc,
    framework::Scope* scope, const platform::Place& place,
47
    int64_t num_micro_batches, const std::vector<TaskNode*>& task_nodes,
48
    const std::unordered_map<int64_t, int64_t>& task_id_to_rank) {
49 50 51 52 53 54 55 56
  PADDLE_ENFORCE_GT(task_nodes.size(), 0,
                    platform::errors::InvalidArgument(
                        "Fleet executor is inited with empty task node"));
  // TODO(fleet_exe devs): the unused_vars should be got from run time graph
  std::vector<std::unique_ptr<framework::OperatorBase>> ops;
  for (auto task_node : task_nodes) {
    for (auto op : task_node->ops()) {
      ops.emplace_back(std::unique_ptr<framework::OperatorBase>(op));
57
    }
58
  }
59 60 61 62 63 64 65 66 67 68 69 70 71
  auto unused_vars = framework::GetUnusedVars(program_desc.Block(0), ops, {});
  runtime_graph_ = std::make_shared<RuntimeGraph>();
  std::unordered_map<int64_t, TaskNode*> interceptor_id_to_task;
  for (auto task_node : task_nodes) {
    task_node->SetUnusedVars(unused_vars);
    int64_t interceptor_id = task_node->task_id();
    interceptor_id_to_task.emplace(interceptor_id, task_node);
  }
  runtime_graph_->SetInterceptorIdToRank(task_id_to_rank);
  runtime_graph_->SetInterceptorIdToNode(interceptor_id_to_task);
  for (auto& unique_op : ops) {
    unique_op.release();
  }
72
  VLOG(5) << runtime_graph_->DebugString();
73 74 75
  Carrier* carrier =
      GlobalMap<std::string, Carrier>::Create(carrier_id, carrier_id);
  carrier_ids_.insert(carrier_id);
76 77
  // Set current running carrier
  GlobalVal<std::string>::Set(new std::string(carrier_id));
78
  InitCarrier(carrier, scope, place, num_micro_batches, program_desc);
79
  GlobalVal<MessageBus>::Get()->Barrier();
80 81
}

82 83 84 85
void FleetExecutor::InitCarrier(Carrier* carrier, framework::Scope* scope,
                                const platform::Place& place,
                                int64_t num_micro_batches,
                                const framework::ProgramDesc& program_desc) {
86
  carrier->Init(exe_desc_.cur_rank(), runtime_graph_->interceptor_id_to_rank(),
87 88
                runtime_graph_->interceptor_id_to_node(), program_desc, scope,
                num_micro_batches, place);
89 90
}

91 92 93 94 95 96 97
void FleetExecutor::InitMessageBus() {
  std::stringstream ss;
  ss << "\nThe DNS table of the message bus is: \n";
  int64_t cur_rank = exe_desc_.cur_rank();
  std::unordered_map<int64_t, std::string> rank_to_addr;
  std::string addr;
  for (const auto& rank_info : exe_desc_.cluster_info()) {
98
    // init the dns map
99 100 101 102 103 104 105 106
    int64_t rank = rank_info.rank();
    std::string ip_port = rank_info.ip_port();
    ss << rank << "\t->\t" << ip_port << "\n";
    rank_to_addr.insert(std::make_pair(rank, ip_port));
    if (rank == cur_rank) {
      addr = ip_port;
    }
  }
107 108
  if (addr == "") {
    PADDLE_ENFORCE_EQ(
109
        rank_to_addr.size(), 1,
110 111 112 113 114 115 116 117 118 119
        platform::errors::NotFound("Empty address is not valid for "
                                   "paddle.distributed.launch method."));
    PADDLE_ENFORCE_EQ(
        cur_rank, 0,
        platform::errors::NotFound("Address is empty but cur rank is not 0."));
  }
  VLOG(3) << "Current rank is " << cur_rank << " and the ip_port is "
          << (addr == "" ? "empty" : addr) << ".";
  VLOG(3) << "The number of ranks are "
          << (rank_to_addr.size() == 0 ? 1 : rank_to_addr.size()) << ".";
120
  VLOG(5) << ss.str();
121
  GlobalVal<MessageBus>::Get()->Init(cur_rank, rank_to_addr, addr);
L
LiYuRio 已提交
122 123
}

124
void FleetExecutor::Run(const std::string& carrier_id) {
125 126 127 128 129 130 131
  Carrier* carrier = GlobalMap<std::string, Carrier>::Get(carrier_id);
  // Set current running carrier
  if (*GlobalVal<std::string>::Get() != carrier_id) {
    GlobalVal<std::string>::Set(new std::string(carrier_id));
    GlobalVal<MessageBus>::Get()->Barrier();
  }
  carrier->Start();
L
LiYuRio 已提交
132 133 134 135
}

}  // namespace distributed
}  // namespace paddle