liaogang
8 years ago
commit
49fd49f76b
@ -0,0 +1,20 @@
|
||||
#include "paddle/framework/net.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
PlainNet::PlainNet(const NetDesc& def) {}
|
||||
|
||||
void PlainNet::InferShape(Scope* scope) {
|
||||
for (auto& op : ops_) {
|
||||
op.InferShape();
|
||||
}
|
||||
}
|
||||
|
||||
void PlainNet::Run(std::shared_ptr<Scope> scope, DeviceContext* ctx) {
|
||||
for (auto& op : ops_) {
|
||||
op.Run(ctx);
|
||||
}
|
||||
}
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,171 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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 "paddle/framework/net_proto.pb.h"
|
||||
#include "paddle/framework/op_proto.pb.h"
|
||||
#include "paddle/framework/scope.h"
|
||||
#include "paddle/platform/device_context.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
using namespace paddle::platform;
|
||||
|
||||
// operator's index stored in a network.
|
||||
typedef int OpIndex;
|
||||
/**
|
||||
* NOTE following codes are some definitions of unimplemented concepts.
|
||||
* We write some basic implementation to make Net compilable. These APIs will
|
||||
* keep updating if the concepts related are implemented.
|
||||
*/
|
||||
|
||||
struct OpDesc;
|
||||
struct OpAttrs {};
|
||||
|
||||
class Operator {
|
||||
public:
|
||||
Operator(const OpDesc &def) {}
|
||||
void InferShape() {}
|
||||
void Run(DeviceContext *ctx) {}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Network that manage the operators it has.
|
||||
*
|
||||
* Network is the container and controller of a set of operators, user can build
|
||||
* a real network from a NetDesc which is a protobuf message and use
|
||||
* Network.Run() * to run all the operators in the network.
|
||||
|
||||
* A network object knows all Operators belonging to this network. Variables,
|
||||
* which are inputs and outputs of these operators, are created and managed by a
|
||||
* hierarchy of Scope objects.
|
||||
*
|
||||
* This is the base class of network, all the networks should implement the apis
|
||||
* it defines.
|
||||
*/
|
||||
class Net {
|
||||
public:
|
||||
/**
|
||||
* @brief Infer shapes of all inputs and outputs of operators.
|
||||
*/
|
||||
virtual void InferShape(Scope *scope) = 0;
|
||||
/**
|
||||
* @brief Run the network.
|
||||
*
|
||||
* Run all the operators and return success(true) or not, with all the
|
||||
* variables are located in `scope`. `context` describes the detail execution
|
||||
* environment for ops. `begin` and `end` specify the scope of `ops_` to run,
|
||||
* If no positive indexes are provided, all operators in `ops_` will run.
|
||||
*/
|
||||
virtual void Run(std::shared_ptr<Scope> scope, DeviceContext *ctx) = 0;
|
||||
|
||||
/**
|
||||
* @brief Add an Operator according to `def`.
|
||||
*/
|
||||
virtual OpIndex AddOp(const OpProto &def) = 0;
|
||||
|
||||
/**
|
||||
* @brief Add optimizer operators acctording to `attrs`.
|
||||
*/
|
||||
virtual void AddOptimizerOps(const OpAttrs &attrs) = 0;
|
||||
|
||||
/**
|
||||
* @brief Add backward operators.
|
||||
*/
|
||||
virtual void AddBackwardOps() = 0;
|
||||
|
||||
/**
|
||||
* @brief Create a network.
|
||||
*/
|
||||
static std::unique_ptr<Net> Create(const NetDesc &def = NetDesc());
|
||||
|
||||
virtual ~Net() {}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief a basic implementation of Net.
|
||||
*
|
||||
* PlainNet is a very simple Net, it create a list of operators, and run them
|
||||
* sequentially following the order they added.
|
||||
*/
|
||||
class PlainNet : public Net {
|
||||
public:
|
||||
/**
|
||||
* @brief Initialize a PlainNet.
|
||||
*
|
||||
* Initialize from a network describe by `def`. NetDesc is the definition of
|
||||
* a network.
|
||||
*/
|
||||
PlainNet(const NetDesc &def);
|
||||
|
||||
/**
|
||||
* Infer all the operators' input and output varialbes' shapes, will be called
|
||||
* before every mini-batch
|
||||
*/
|
||||
virtual void InferShape(Scope *scope) override;
|
||||
|
||||
/**
|
||||
* @brief Run the network.
|
||||
*
|
||||
* Run all the operators with the `scope`, if no scope is provided, default
|
||||
* scope will be used instead. If no OpContext is provicded, default context
|
||||
* will be used.
|
||||
*/
|
||||
virtual void Run(std::shared_ptr<Scope> scope, DeviceContext *ctx) override;
|
||||
|
||||
/**
|
||||
* @brief Add an operator to this network.
|
||||
*/
|
||||
virtual OpIndex AddOp(const OpProto &def) override;
|
||||
|
||||
/**
|
||||
* @brief Add all optimizer operators related into the network.
|
||||
*/
|
||||
virtual void AddOptimizerOps(const OpAttrs &attrs) override;
|
||||
|
||||
/**
|
||||
* @brief Add all backward operators related into the network.
|
||||
*/
|
||||
virtual void AddBackwardOps() override;
|
||||
|
||||
virtual ~PlainNet() override {}
|
||||
|
||||
protected:
|
||||
/**
|
||||
* @brief Build the network.
|
||||
*
|
||||
* Create operators accordding to `def`, will be called by the constructor.
|
||||
*/
|
||||
void BuildNet(const NetDesc &def);
|
||||
|
||||
/**
|
||||
* @brief Add an operator into this network.
|
||||
*
|
||||
* Add a operator which is identified as `type` and has attributes described
|
||||
* in `attrs`, the `inputs` are the keys of readonly input variables,
|
||||
* `outputs` are keys of mutable output variables. An `OpIndex` will be
|
||||
* returned to indicate the offset of the new operator in `ops_`.
|
||||
*/
|
||||
OpIndex AddOp(const std::string &type, const std::vector<std::string> &inputs,
|
||||
const std::vector<std::string> &outputs,
|
||||
const OpAttrs &attrs = OpAttrs());
|
||||
|
||||
private:
|
||||
// the operators owned by `Network`.
|
||||
std::vector<Operator> ops_;
|
||||
};
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,15 @@
|
||||
syntax="proto2";
|
||||
package paddle.framework;
|
||||
|
||||
import "op_proto.proto";
|
||||
|
||||
message NetDesc {
|
||||
// network identification
|
||||
optional string name = 1;
|
||||
// operator contains in network
|
||||
repeated OpProto operators = 2;
|
||||
// network type to run with. e.g "plainNet", "DAG"
|
||||
optional string net_type = 3;
|
||||
// num worker always
|
||||
optional int32 num_workers = 4;
|
||||
}
|
||||
@ -0,0 +1,24 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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/framework/net.h"
|
||||
#include "paddle/framework/op_registry.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
class FakeFC : public Operator {}
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,160 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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 "paddle/framework/enforce.h"
|
||||
#ifndef PADDLE_ONLY_CPU
|
||||
#include "paddle/platform/cuda.h"
|
||||
#include "paddle/platform/dynload/cublas.h"
|
||||
#include "paddle/platform/dynload/cudnn.h"
|
||||
#include "paddle/platform/dynload/curand.h"
|
||||
#define EIGEN_USE_GPU
|
||||
#endif
|
||||
#include "paddle/platform/place.h"
|
||||
#include "unsupported/Eigen/CXX11/Tensor"
|
||||
|
||||
namespace paddle {
|
||||
namespace platform {
|
||||
|
||||
class DeviceContext {
|
||||
public:
|
||||
virtual ~DeviceContext() {}
|
||||
};
|
||||
|
||||
class CPUDeviceContext : public DeviceContext {};
|
||||
|
||||
#ifndef PADDLE_ONLY_CPU
|
||||
|
||||
class GPUPlaceGuard {
|
||||
public:
|
||||
explicit GPUPlaceGuard(GPUPlace new_place) : previous_(GetCurrentDeviceId()) {
|
||||
if (previous_ != new_place) {
|
||||
paddle::platform::SetDeviceId(new_place.device);
|
||||
}
|
||||
}
|
||||
|
||||
~GPUPlaceGuard() { paddle::platform::SetDeviceId(previous_.device); }
|
||||
|
||||
private:
|
||||
GPUPlace previous_;
|
||||
};
|
||||
|
||||
class CUDADeviceContext : public DeviceContext {
|
||||
public:
|
||||
explicit CUDADeviceContext(const GPUPlace gpu_place) : gpu_place_(gpu_place) {
|
||||
GPUPlaceGuard guard(gpu_place_);
|
||||
paddle::platform::throw_on_error(cudaStreamCreate(&stream_),
|
||||
"cudaStreamCreate failed");
|
||||
eigen_stream_ = new Eigen::CudaStreamDevice(&stream_);
|
||||
eigen_device_ = new Eigen::GpuDevice(eigen_stream_);
|
||||
}
|
||||
|
||||
void Wait() {
|
||||
paddle::platform::throw_on_error(cudaStreamSynchronize(stream_),
|
||||
"cudaStreamSynchronize failed");
|
||||
}
|
||||
|
||||
cudaStream_t stream() { return stream_; }
|
||||
|
||||
Eigen::GpuDevice eigen_device() { return *eigen_device_; }
|
||||
|
||||
cublasHandle_t cublas_handle() {
|
||||
if (!blas_handle_) {
|
||||
GPUPlaceGuard guard(gpu_place_);
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cublasCreate(&blas_handle_) ==
|
||||
CUBLAS_STATUS_SUCCESS,
|
||||
"cublasCreate failed");
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cublasSetStream(
|
||||
blas_handle_, stream_) == CUBLAS_STATUS_SUCCESS,
|
||||
"cublasSetStream failed");
|
||||
}
|
||||
return blas_handle_;
|
||||
}
|
||||
|
||||
cudnnHandle_t cudnn_handle() {
|
||||
if (!dnn_handle_) {
|
||||
GPUPlaceGuard guard(gpu_place_);
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cudnnCreate(&dnn_handle_) ==
|
||||
CUDNN_STATUS_SUCCESS,
|
||||
"cudnnCreate failed");
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cudnnSetStream(
|
||||
dnn_handle_, stream_) == CUDNN_STATUS_SUCCESS,
|
||||
"cudnnSetStream failed");
|
||||
}
|
||||
return dnn_handle_;
|
||||
}
|
||||
|
||||
curandGenerator_t curand_generator() {
|
||||
if (!rand_generator_) {
|
||||
GPUPlaceGuard guard(gpu_place_);
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::curandCreateGenerator(
|
||||
&rand_generator_, CURAND_RNG_PSEUDO_DEFAULT) ==
|
||||
CURAND_STATUS_SUCCESS,
|
||||
"curandCreateGenerator failed");
|
||||
PADDLE_ENFORCE(
|
||||
paddle::platform::dynload::curandSetPseudoRandomGeneratorSeed(
|
||||
rand_generator_, random_seed_) == CURAND_STATUS_SUCCESS,
|
||||
"curandSetPseudoRandomGeneratorSeed failed");
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::curandSetStream(
|
||||
rand_generator_, stream_) == CURAND_STATUS_SUCCESS,
|
||||
"curandSetStream failed");
|
||||
}
|
||||
return rand_generator_;
|
||||
}
|
||||
|
||||
~CUDADeviceContext() {
|
||||
Wait();
|
||||
if (blas_handle_) {
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cublasDestroy(blas_handle_) ==
|
||||
CUBLAS_STATUS_SUCCESS,
|
||||
"cublasDestroy failed");
|
||||
}
|
||||
|
||||
if (dnn_handle_) {
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::cudnnDestroy(dnn_handle_) ==
|
||||
CUDNN_STATUS_SUCCESS,
|
||||
"cudnnDestroy failed");
|
||||
}
|
||||
|
||||
if (rand_generator_) {
|
||||
PADDLE_ENFORCE(paddle::platform::dynload::curandDestroyGenerator(
|
||||
rand_generator_) == CURAND_STATUS_SUCCESS,
|
||||
"curandDestroyGenerator failed");
|
||||
}
|
||||
|
||||
delete eigen_stream_;
|
||||
delete eigen_device_;
|
||||
|
||||
paddle::platform::throw_on_error(cudaStreamDestroy(stream_),
|
||||
"cudaStreamDestroy failed");
|
||||
}
|
||||
|
||||
private:
|
||||
GPUPlace gpu_place_;
|
||||
cudaStream_t stream_;
|
||||
|
||||
Eigen::CudaStreamDevice* eigen_stream_;
|
||||
Eigen::GpuDevice* eigen_device_;
|
||||
|
||||
cublasHandle_t blas_handle_{nullptr};
|
||||
|
||||
cudnnHandle_t dnn_handle_{nullptr};
|
||||
|
||||
int random_seed_;
|
||||
curandGenerator_t rand_generator_{nullptr};
|
||||
};
|
||||
#endif
|
||||
} // namespace platform
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,33 @@
|
||||
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
|
||||
|
||||
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/platform/device_context.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
TEST(CUDADeviceContext, Init) {
|
||||
int count = paddle::platform::GetDeviceCount();
|
||||
for (int i = 0; i < count; i++) {
|
||||
paddle::platform::CUDADeviceContext* device_context =
|
||||
new paddle::platform::CUDADeviceContext(i);
|
||||
Eigen::GpuDevice gpu_device = device_context->eigen_device();
|
||||
ASSERT_NE(nullptr, gpu_device.stream());
|
||||
cudnnHandle_t cudnn_handle = device_context->cudnn_handle();
|
||||
ASSERT_NE(nullptr, cudnn_handle);
|
||||
cublasHandle_t cublas_handle = device_context->cublas_handle();
|
||||
ASSERT_NE(nullptr, cublas_handle);
|
||||
curandGenerator_t curand_handle = device_context->curand_generator();
|
||||
ASSERT_NE(nullptr, curand_handle);
|
||||
delete device_context;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue