Merge branch 'add-communicator' of ssh://github.com/jacquesqiao/Paddle into add-async-ssa-graph-executor-communicator
Qiao Longfei
6 years ago
commit
fab1b54d99
@ -0,0 +1,139 @@
|
||||
/* Copyright (c) 2019 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/operators/distributed/communicator.h"
|
||||
|
||||
#include "paddle/fluid/framework/selected_rows.h"
|
||||
#include "paddle/fluid/framework/tensor_util.h"
|
||||
#include "paddle/fluid/framework/variable_helper.h"
|
||||
#include "paddle/fluid/operators/distributed/parameter_recv.h"
|
||||
#include "paddle/fluid/operators/distributed/parameter_send.h"
|
||||
#include "paddle/fluid/operators/math/selected_rows_functor.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
static inline void MergeVars(const std::string &var_name,
|
||||
const std::vector<std::shared_ptr<Variable>> &vars,
|
||||
Scope *scope) {
|
||||
PADDLE_ENFORCE(!vars.empty(), "should have value to merge!");
|
||||
auto cpu_place = platform::CPUPlace();
|
||||
auto &var0 = vars[0];
|
||||
auto *out_var = scope->Var(var_name);
|
||||
if (var0->IsType<framework::LoDTensor>()) {
|
||||
auto *out_t = out_var->GetMutable<framework::LoDTensor>();
|
||||
auto *out_ptr = out_t->mutable_data<float>(
|
||||
var0->Get<framework::LoDTensor>().dims(), cpu_place);
|
||||
auto numel = out_t->numel();
|
||||
for (auto i = 0; i < numel; ++i) {
|
||||
out_ptr[i] = 0;
|
||||
for (auto &var : vars) {
|
||||
auto &var_t = var->Get<framework::LoDTensor>();
|
||||
PADDLE_ENFORCE_EQ(var_t.numel(), numel, "should have the same dims");
|
||||
out_ptr[i] += var_t.data<float>()[i];
|
||||
}
|
||||
}
|
||||
} else if (var0->IsType<framework::SelectedRows>()) {
|
||||
auto *out_slr = out_var->GetMutable<framework::SelectedRows>();
|
||||
out_slr->mutable_rows()->clear();
|
||||
out_slr->mutable_value()->mutable_data<float>({{}}, cpu_place);
|
||||
std::vector<const paddle::framework::SelectedRows *> inputs;
|
||||
inputs.reserve(vars.size());
|
||||
for (auto &var : vars) {
|
||||
inputs.push_back(&var->Get<framework::SelectedRows>());
|
||||
}
|
||||
math::scatter::MergeAdd<paddle::platform::CPUDeviceContext, float>
|
||||
merge_add;
|
||||
auto dev_ctx = paddle::platform::CPUDeviceContext();
|
||||
merge_add(dev_ctx, inputs, out_slr, false);
|
||||
} else {
|
||||
PADDLE_THROW("unsupported var type!");
|
||||
}
|
||||
}
|
||||
|
||||
void Communicator::SendThread() {
|
||||
while (running_) {
|
||||
std::vector<std::future<void>> task_futures;
|
||||
task_futures.reserve(send_varname_to_ctx_.size());
|
||||
for (auto &iter : send_varname_to_queue_) {
|
||||
auto send_task = [this, &iter] {
|
||||
auto &var_name = iter.first;
|
||||
VLOG(3) << "merge var " << var_name << " and send";
|
||||
auto &var_queue = iter.second;
|
||||
std::vector<std::shared_ptr<Variable>> vars;
|
||||
// TODO(qiao): need to be configurable
|
||||
const size_t max_merge_var_num = 20;
|
||||
size_t merged_var_num = 0;
|
||||
while (var_queue->Size() > 0 && merged_var_num < max_merge_var_num) {
|
||||
vars.push_back(var_queue->Pop());
|
||||
merged_var_num++;
|
||||
}
|
||||
MergeVars(var_name, vars, send_scope_.get());
|
||||
auto send_functor = distributed::ParameterSend<float>();
|
||||
auto &ctx = send_varname_to_ctx_.at(var_name);
|
||||
send_functor(ctx, *send_scope_, true);
|
||||
};
|
||||
task_futures.emplace_back(
|
||||
send_threadpool_->enqueue(std::move(send_task)));
|
||||
}
|
||||
for (auto &task_f : task_futures) {
|
||||
task_f.wait();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Communicator::RecvThread() {
|
||||
while (running_) {
|
||||
// parallel run recv graph
|
||||
std::vector<std::future<void>> task_futures;
|
||||
task_futures.reserve(recv_varname_to_ctx_.size());
|
||||
for (auto &iter : recv_varname_to_ctx_) {
|
||||
auto recv_task = [this, &iter] {
|
||||
auto &var_name = iter.first;
|
||||
VLOG(3) << "recv var " << var_name;
|
||||
auto recv_functor = distributed::ParameterRecv<float>();
|
||||
recv_functor(iter.second, *recv_scope_);
|
||||
};
|
||||
task_futures.emplace_back(
|
||||
recv_threadpool_->enqueue(std::move(recv_task)));
|
||||
}
|
||||
for (auto &task : task_futures) {
|
||||
task.wait();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Communicator::Send(const std::string &var_name,
|
||||
const framework::Scope &scope) {
|
||||
// push var into send queue by var_name
|
||||
auto *grad_var = scope.FindVar(var_name);
|
||||
PADDLE_ENFORCE(grad_var->IsInitialized(), "grad var should be inited");
|
||||
auto tmp_grad_var = std::make_shared<Variable>();
|
||||
framework::CopyVariable(*grad_var, tmp_grad_var.get());
|
||||
send_varname_to_queue_[var_name]->Push(tmp_grad_var);
|
||||
}
|
||||
|
||||
void Communicator::Start() {
|
||||
running_ = true;
|
||||
// start send and recv thread
|
||||
send_thread_.reset(
|
||||
new std::thread(std::bind(&Communicator::SendThread, this)));
|
||||
recv_thread_.reset(
|
||||
new std::thread(std::bind(&Communicator::RecvThread, this)));
|
||||
}
|
||||
|
||||
} // namespace distributed
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,143 @@
|
||||
/* Copyright (c) 2019 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <ThreadPool.h>
|
||||
|
||||
#include "paddle/fluid/framework/scope.h"
|
||||
#include "paddle/fluid/framework/variable.h"
|
||||
#include "paddle/fluid/operators/distributed/rpc_common.h"
|
||||
#include "paddle/fluid/platform/device_context.h"
|
||||
#include "paddle/fluid/platform/enforce.h"
|
||||
#include "paddle/fluid/platform/place.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
using Scope = framework::Scope;
|
||||
using Variable = framework::Variable;
|
||||
|
||||
template <typename T>
|
||||
class BlockingQueue {
|
||||
public:
|
||||
explicit BlockingQueue(size_t capacity) : capacity_(capacity) {
|
||||
PADDLE_ENFORCE_GT(capacity_, 0, "The capacity must be greater than 0.");
|
||||
}
|
||||
|
||||
bool Push(const T& elem) {
|
||||
std::unique_lock<std::mutex> lock(mutex_);
|
||||
send_cv_.wait(lock, [&] { return queue_.size() < capacity_; });
|
||||
PADDLE_ENFORCE_LT(queue_.size(), capacity_);
|
||||
queue_.push_back(elem);
|
||||
recv_cv_.notify_one();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Push(T&& elem) {
|
||||
std::unique_lock<std::mutex> lock(mutex_);
|
||||
send_cv_.wait(lock, [&] { return queue_.size() < capacity_; });
|
||||
PADDLE_ENFORCE_LT(queue_.size(), capacity_);
|
||||
queue_.emplace_back(std::move(elem));
|
||||
recv_cv_.notify_one();
|
||||
return true;
|
||||
}
|
||||
|
||||
T Pop() {
|
||||
std::unique_lock<std::mutex> lock(mutex_);
|
||||
recv_cv_.wait(lock, [=] { return !queue_.empty(); });
|
||||
T rc(std::move(queue_.front()));
|
||||
queue_.pop_front();
|
||||
return rc;
|
||||
}
|
||||
|
||||
size_t Cap() const {
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
return capacity_;
|
||||
}
|
||||
|
||||
size_t Size() const {
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
return queue_.size();
|
||||
}
|
||||
|
||||
private:
|
||||
const size_t capacity_;
|
||||
std::deque<T> queue_;
|
||||
|
||||
mutable std::mutex mutex_;
|
||||
std::condition_variable recv_cv_;
|
||||
std::condition_variable send_cv_;
|
||||
};
|
||||
|
||||
class Communicator {
|
||||
public:
|
||||
Communicator(
|
||||
const std::unordered_map<std::string, RpcContext>& send_varname_to_ctx,
|
||||
const std::unordered_map<std::string, RpcContext>& recv_varname_to_ctx,
|
||||
Scope* recv_scope)
|
||||
: send_varname_to_ctx_(send_varname_to_ctx),
|
||||
recv_varname_to_ctx_(recv_varname_to_ctx),
|
||||
recv_scope_(recv_scope) {
|
||||
// get all send information from graph, build vars_to_send
|
||||
send_scope_.reset(new Scope());
|
||||
for (auto& iter : send_varname_to_ctx_) {
|
||||
send_varname_to_queue_[iter.first] =
|
||||
std::make_shared<BlockingQueue<std::shared_ptr<Variable>>>(10);
|
||||
}
|
||||
// TODO(qiao): default 5, need to config
|
||||
send_threadpool_.reset(new ::ThreadPool(5));
|
||||
recv_threadpool_.reset(new ::ThreadPool(5));
|
||||
}
|
||||
|
||||
~Communicator() {
|
||||
VLOG(3) << "~Communicator";
|
||||
running_ = false;
|
||||
send_thread_->join();
|
||||
recv_thread_->join();
|
||||
VLOG(3) << "~Communicator done";
|
||||
}
|
||||
|
||||
void Start();
|
||||
|
||||
// send grad
|
||||
void Send(const std::string& var_name, const framework::Scope& scope);
|
||||
|
||||
private:
|
||||
void SendThread();
|
||||
void RecvThread();
|
||||
|
||||
bool running_ = false;
|
||||
std::unordered_map<std::string,
|
||||
std::shared_ptr<BlockingQueue<std::shared_ptr<Variable>>>>
|
||||
send_varname_to_queue_;
|
||||
std::unordered_map<std::string, RpcContext> send_varname_to_ctx_;
|
||||
std::unordered_map<std::string, RpcContext> recv_varname_to_ctx_;
|
||||
std::unique_ptr<std::thread> send_thread_;
|
||||
std::unique_ptr<std::thread> recv_thread_;
|
||||
Scope* recv_scope_; // should be global scope
|
||||
std::unique_ptr<Scope> send_scope_; // an independent scope
|
||||
std::unique_ptr<::ThreadPool> send_threadpool_{nullptr};
|
||||
std::unique_ptr<::ThreadPool> recv_threadpool_{nullptr};
|
||||
};
|
||||
|
||||
} // namespace distributed
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,99 @@
|
||||
// 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 <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "paddle/fluid/operators/distributed/parameter_recv.h"
|
||||
|
||||
#include "paddle/fluid/framework/lod_tensor.h"
|
||||
#include "paddle/fluid/framework/scope.h"
|
||||
#include "paddle/fluid/framework/selected_rows.h"
|
||||
#include "paddle/fluid/framework/tensor.h"
|
||||
|
||||
#include "paddle/fluid/operators/distributed/distributed.h"
|
||||
#include "paddle/fluid/operators/distributed/rpc_client.h"
|
||||
#include "paddle/fluid/operators/distributed/variable_response.h"
|
||||
#include "paddle/fluid/operators/distributed_ops/send_recv_util.h"
|
||||
#include "paddle/fluid/operators/strided_memcpy.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
using LoDTensor = framework::LoDTensor;
|
||||
using LoDTensor = framework::LoDTensor;
|
||||
using SelectedRows = framework::SelectedRows;
|
||||
using DDim = framework::DDim;
|
||||
|
||||
template <typename T>
|
||||
void ParameterRecv<T>::operator()(const RpcContext &rpc_ctx,
|
||||
const framework::Scope &scope) {
|
||||
framework::Scope *local_scope = scope.NewTmpScope();
|
||||
|
||||
platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance();
|
||||
auto &cpu_ctx = *pool.Get(platform::CPUPlace());
|
||||
|
||||
distributed::RPCClient *rpc_client =
|
||||
distributed::RPCClient::GetInstance<RPCCLIENT_T>(0);
|
||||
|
||||
auto *recv_var = scope.FindVar(rpc_ctx.var_name);
|
||||
|
||||
std::vector<framework::Tensor *> recved_tensors;
|
||||
|
||||
// recv all vars to local scope
|
||||
if (recv_var->IsType<framework::LoDTensor>()) {
|
||||
std::vector<distributed::VarHandlePtr> rets;
|
||||
for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) {
|
||||
auto &recv_var_name = rpc_ctx.splited_var_names[i];
|
||||
framework::Tensor *t =
|
||||
local_scope->Var(recv_var_name)->GetMutable<framework::LoDTensor>();
|
||||
recved_tensors.push_back(t);
|
||||
VLOG(3) << "recv " << recv_var_name << " from " << rpc_ctx.epmap[i];
|
||||
rets.push_back(rpc_client->AsyncGetVar(rpc_ctx.epmap[i], cpu_ctx,
|
||||
*local_scope, recv_var_name,
|
||||
recv_var_name));
|
||||
}
|
||||
for (size_t i = 0; i < rets.size(); i++) {
|
||||
PADDLE_ENFORCE(rets[i]->Wait(), "internal error in RPCClient");
|
||||
}
|
||||
} else {
|
||||
PADDLE_THROW("unsupported var type to recv!");
|
||||
}
|
||||
|
||||
// concat recved tensor into one var
|
||||
{
|
||||
size_t output_offset = 0;
|
||||
framework::Tensor *recv_tensor =
|
||||
recv_var->GetMutable<framework::LoDTensor>();
|
||||
auto dev_ctx = paddle::platform::CPUDeviceContext();
|
||||
for (auto *in : recved_tensors) {
|
||||
auto in_stride = framework::stride_numel(in->dims());
|
||||
auto out_stride = framework::stride_numel(recv_tensor->dims());
|
||||
StridedNumelCopyWithAxis<T>(
|
||||
dev_ctx, 0, recv_tensor->data<T>() + output_offset, out_stride,
|
||||
in->data<T>(), in_stride, in_stride[0]);
|
||||
output_offset += in_stride[0];
|
||||
}
|
||||
}
|
||||
|
||||
delete local_scope;
|
||||
}
|
||||
|
||||
template struct ParameterRecv<float>;
|
||||
|
||||
}; // namespace distributed
|
||||
}; // namespace operators
|
||||
}; // namespace paddle
|
||||
@ -0,0 +1,34 @@
|
||||
// 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "paddle/fluid/framework/operator.h"
|
||||
#include "paddle/fluid/operators/distributed/rpc_common.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
template <typename T>
|
||||
struct ParameterRecv {
|
||||
void operator()(const RpcContext &rpc_ctx, const framework::Scope &scope);
|
||||
};
|
||||
|
||||
}; // namespace distributed
|
||||
}; // namespace operators
|
||||
}; // namespace paddle
|
||||
@ -0,0 +1,177 @@
|
||||
// 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 <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "paddle/fluid/operators/distributed/parameter_send.h"
|
||||
|
||||
#include "paddle/fluid/framework/lod_tensor.h"
|
||||
#include "paddle/fluid/framework/scope.h"
|
||||
#include "paddle/fluid/framework/selected_rows.h"
|
||||
#include "paddle/fluid/framework/tensor.h"
|
||||
|
||||
#include "paddle/fluid/operators/distributed/distributed.h"
|
||||
#include "paddle/fluid/operators/distributed/rpc_client.h"
|
||||
#include "paddle/fluid/operators/distributed/variable_response.h"
|
||||
#include "paddle/fluid/operators/distributed_ops/send_recv_util.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
using LoDTensor = framework::LoDTensor;
|
||||
using LoDTensor = framework::LoDTensor;
|
||||
using SelectedRows = framework::SelectedRows;
|
||||
using DDim = framework::DDim;
|
||||
|
||||
template <typename T>
|
||||
void ParameterSend<T>::operator()(const RpcContext &rpc_ctx,
|
||||
const framework::Scope &scope, bool sync) {
|
||||
framework::Scope *local_scope = scope.NewTmpScope();
|
||||
|
||||
platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance();
|
||||
auto &cpu_ctx = *pool.Get(platform::CPUPlace());
|
||||
|
||||
distributed::RPCClient *rpc_client =
|
||||
distributed::RPCClient::GetInstance<RPCCLIENT_T>(0);
|
||||
|
||||
auto *send_var = scope.FindVar(rpc_ctx.var_name);
|
||||
size_t out_num = rpc_ctx.splited_var_names.size();
|
||||
if (send_var->IsType<framework::LoDTensor>()) {
|
||||
if (out_num > 1) {
|
||||
auto &send_tensor = send_var->Get<framework::LoDTensor>();
|
||||
auto &send_tensor_dims = send_tensor.dims();
|
||||
std::vector<framework::DDim> outs_dims;
|
||||
outs_dims.reserve(out_num);
|
||||
|
||||
// infer output shape
|
||||
PADDLE_ENFORCE_EQ(rpc_ctx.height_sections.size(), out_num,
|
||||
"tensor split sections size"
|
||||
"should be equal to output size.");
|
||||
for (size_t i = 0; i < out_num; ++i) {
|
||||
auto dim = send_tensor_dims;
|
||||
dim[0] = rpc_ctx.height_sections[i];
|
||||
outs_dims.push_back(dim);
|
||||
}
|
||||
|
||||
// create output var in local scope
|
||||
size_t row_offset = 0;
|
||||
for (auto i = 0; i < out_num; ++i) {
|
||||
framework::Tensor *out = local_scope->Var(rpc_ctx.splited_var_names[i])
|
||||
->GetMutable<framework::LoDTensor>();
|
||||
*out = send_tensor.Slice(row_offset, row_offset + outs_dims[i][0]);
|
||||
row_offset += outs_dims[i][0];
|
||||
}
|
||||
}
|
||||
} else if (send_var->IsType<framework::SelectedRows>()) {
|
||||
auto &send_slr = send_var->Get<framework::SelectedRows>();
|
||||
auto abs_sections = ToAbsoluteSection(rpc_ctx.height_sections);
|
||||
|
||||
auto send_rows = send_slr.rows();
|
||||
std::vector<std::vector<int>> outs_rows_idx;
|
||||
std::vector<std::vector<int>> outs_dense_idx;
|
||||
|
||||
outs_rows_idx.resize(out_num);
|
||||
outs_dense_idx.resize(out_num);
|
||||
|
||||
auto row_numel = send_slr.value().numel() / send_slr.value().dims()[0];
|
||||
auto src = send_slr.value().data<T>();
|
||||
|
||||
// create output var in local scope
|
||||
std::vector<framework::SelectedRows *> outs;
|
||||
for (auto &name : rpc_ctx.splited_var_names) {
|
||||
auto *out = local_scope->Var(name)->GetMutable<framework::SelectedRows>();
|
||||
outs.push_back(out);
|
||||
}
|
||||
|
||||
// split rows index into output sparse vars
|
||||
for (size_t i = 0; i < send_rows.size(); ++i) {
|
||||
int out_idx = FindOutIdx(send_rows[i], abs_sections);
|
||||
outs_rows_idx[out_idx].push_back(send_rows[i]);
|
||||
outs_dense_idx[out_idx].push_back(i);
|
||||
}
|
||||
auto place = platform::CPUPlace();
|
||||
|
||||
for (size_t i = 0; i < outs_rows_idx.size(); ++i) {
|
||||
auto rows_idx = outs_rows_idx[i];
|
||||
outs[i]->set_height(rpc_ctx.height_sections[i]);
|
||||
auto dims = send_slr.GetCompleteDims();
|
||||
dims[0] = rows_idx.size();
|
||||
outs[i]->mutable_value()->mutable_data<T>(dims, send_slr.place());
|
||||
outs[i]->mutable_rows()->clear();
|
||||
if (rows_idx.size() > 0) {
|
||||
for (auto idx : rows_idx) {
|
||||
outs[i]->mutable_rows()->push_back(idx - abs_sections[i]);
|
||||
}
|
||||
auto dst = outs[i]->mutable_value()->mutable_data<T>(place);
|
||||
for (size_t j = 0; j < rows_idx.size(); j++) {
|
||||
if (platform::is_cpu_place(place)) {
|
||||
memory::Copy(
|
||||
platform::CPUPlace(), dst + j * row_numel, platform::CPUPlace(),
|
||||
src + outs_dense_idx[i][j] * row_numel, sizeof(T) * row_numel);
|
||||
} else {
|
||||
PADDLE_THROW("do not support GPU now");
|
||||
/*
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
auto stream = ctx.cuda_device_context().stream();
|
||||
memory::Copy(platform::CUDAPlace(), dst + j * row_numel,
|
||||
platform::CUDAPlace(),
|
||||
src + outs_dense_idx[i][j] * row_numel,
|
||||
sizeof(T) * row_numel, stream);
|
||||
#else
|
||||
PADDLE_THROW("Paddle is not compiled with GPU");
|
||||
#endif
|
||||
*/
|
||||
}
|
||||
}
|
||||
}
|
||||
PADDLE_ENFORCE_EQ(rows_idx.size(), outs[i]->rows().size(),
|
||||
"rows should has the same size with tensor dim 0");
|
||||
}
|
||||
|
||||
} else {
|
||||
PADDLE_THROW("unsupported var type to send!");
|
||||
}
|
||||
|
||||
std::vector<distributed::VarHandlePtr> rets;
|
||||
for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) {
|
||||
auto &send_var_name = rpc_ctx.splited_var_names[i];
|
||||
auto &endpoint = rpc_ctx.epmap[i];
|
||||
if (NeedSend(*local_scope, send_var_name)) {
|
||||
VLOG(3) << "sending " << send_var_name << " to " << endpoint;
|
||||
rets.push_back(rpc_client->AsyncSendVar(endpoint, cpu_ctx, *local_scope,
|
||||
send_var_name));
|
||||
} else {
|
||||
VLOG(3) << "don't send non-initialized variable: "
|
||||
<< rpc_ctx.splited_var_names[i];
|
||||
}
|
||||
}
|
||||
|
||||
// note!! only support sync send now
|
||||
if (true || sync) {
|
||||
for (size_t i = 0; i < rets.size(); i++) {
|
||||
PADDLE_ENFORCE(rets[i]->Wait(), "internal error in RPCClient");
|
||||
}
|
||||
}
|
||||
|
||||
delete local_scope;
|
||||
}
|
||||
|
||||
template struct ParameterSend<float>;
|
||||
|
||||
}; // namespace distributed
|
||||
}; // namespace operators
|
||||
}; // namespace paddle
|
||||
@ -0,0 +1,35 @@
|
||||
// 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.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "paddle/fluid/framework/operator.h"
|
||||
#include "paddle/fluid/operators/distributed/rpc_common.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
template <typename T>
|
||||
struct ParameterSend {
|
||||
void operator()(const RpcContext &rpc_ctx, const framework::Scope &scope,
|
||||
bool sync);
|
||||
};
|
||||
|
||||
}; // namespace distributed
|
||||
}; // namespace operators
|
||||
}; // namespace paddle
|
||||
@ -0,0 +1,48 @@
|
||||
/* Copyright (c) 2019 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
namespace distributed {
|
||||
|
||||
struct RpcContext {
|
||||
RpcContext(const std::string& name, const std::vector<std::string>& names,
|
||||
const std::vector<std::string>& emap,
|
||||
const std::vector<int64_t>& sections)
|
||||
: var_name(name),
|
||||
splited_var_names(names),
|
||||
epmap(emap),
|
||||
height_sections(sections) {}
|
||||
|
||||
RpcContext(const RpcContext& ctx) {
|
||||
var_name = ctx.var_name;
|
||||
splited_var_names = ctx.splited_var_names;
|
||||
epmap = ctx.epmap;
|
||||
height_sections = ctx.height_sections;
|
||||
}
|
||||
|
||||
std::string var_name;
|
||||
std::vector<std::string> splited_var_names;
|
||||
std::vector<std::string> epmap;
|
||||
std::vector<int64_t> height_sections;
|
||||
};
|
||||
|
||||
} // namespace distributed
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue