finish test

paddle/platform/CMakeLists.txt

@@ -4,4 +4,3 @@ cc_library(place SRCS place.cc)
 cc_test(place_test SRCS place_test.cc DEPS place glog gflags)
 
 cc_library(dynamic_loader SRCS dynamic_loader.cc)
-nv_test(device_context_test SRCS device_context_test.cu DEPS place dynamic_loader glog gflags)

paddle/platform/cuda.h

@@ -33,6 +33,7 @@ int GetDeviceCount(void) {
   throw_on_error(cudaGetDeviceCount(&count), "cudaGetDeviceCount failed");
   return count;
 }
+
 int GetCurrentDeviceId(void) {
   int device_id;
   throw_on_error(cudaGetDevice(&device_id), "cudaGetDevice failed");

paddle/platform/device_context.h

-/* 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
-
-#ifndef PADDLE_ONLY_CPU
-#include "paddle/platform/cublas.h"
-#include "paddle/platform/cuda.h"
-#include "paddle/platform/cudnn.h"
-#include "paddle/platform/curand.h"
-#define EIGEN_USE_GPU
-#endif
-
-#include "paddle/framework/enforce.h"
-#include "paddle/platform/place.h"
-#include "unsupported/Eigen/CXX11/Tensor"
-
-namespace paddle {
-namespace platform {
-
-class DeviceContext {
- public:
-  virtual ~DeviceContext() {}
-};
-
-class CpuDeviceContext : public DeviceContext {
-  Eigen::DefaultDevice eigen_device() {
-    if (!eigen_device_) {
-      eigen_device_ = new Eigen::DefaultDevice();
-    }
-    return *eigen_device_;
-  }
-
- private:
-  Eigen::DefaultDevice* eigen_device_{nullptr};
-};
-
-#ifndef PADDLE_ONLY_CPU
-class DeviceGuard {
- public:
-  explicit DeviceGuard(GPUPlace new_place) : previous_(GetCurrentDeviceId()) {
-    if (previous_ != new_place) {
-      paddle::platform::SetDeviceId(new_place.device);
-    }
-  }
-
-  ~DeviceGuard() { paddle::platform::SetDeviceId(previous_.device); }
-
- private:
-  GPUPlace previous_;
-};
-
-class CudaDeviceContext : public DeviceContext {
- public:
-  explicit CudaDeviceContext(const GPUPlace gpu_place) : gpu_place_(gpu_place) {
-    DeviceGuard 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_) {
-      DeviceGuard guard(gpu_place_);
-      PADDLE_ENFORCE(
-          paddle::dyload::cublasCreate(&blas_handle_) == CUBLAS_STATUS_SUCCESS,
-          "cublasCreate failed");
-      PADDLE_ENFORCE(paddle::dyload::cublasSetStream(blas_handle_, stream_) ==
-                         CUBLAS_STATUS_SUCCESS,
-                     "cublasSetStream failed");
-    }
-    return blas_handle_;
-  }
-
-  cudnnHandle_t cudnn_handle() {
-    if (!dnn_handle_) {
-      DeviceGuard guard(gpu_place_);
-      PADDLE_ENFORCE(
-          paddle::dyload::cudnnCreate(&dnn_handle_) == CUDNN_STATUS_SUCCESS,
-          "cudnnCreate failed");
-      PADDLE_ENFORCE(paddle::dyload::cudnnSetStream(dnn_handle_, stream_) ==
-                         CUDNN_STATUS_SUCCESS,
-                     "cudnnSetStream failed");
-    }
-    return dnn_handle_;
-  }
-
-  curandGenerator_t curand_generator() {
-    if (!rand_generator_) {
-      DeviceGuard guard(gpu_place_);
-      PADDLE_ENFORCE(paddle::dyload::curandCreateGenerator(
-                         &rand_generator_, CURAND_RNG_PSEUDO_DEFAULT) ==
-                         CURAND_STATUS_SUCCESS,
-                     "curandCreateGenerator failed");
-      PADDLE_ENFORCE(
-          paddle::dyload::curandSetPseudoRandomGeneratorSeed(
-              rand_generator_, random_seed_) == CURAND_STATUS_SUCCESS,
-          "curandSetPseudoRandomGeneratorSeed failed");
-      PADDLE_ENFORCE(paddle::dyload::curandSetStream(
-                         rand_generator_, stream_) == CURAND_STATUS_SUCCESS,
-                     "curandSetStream failed");
-    }
-    return rand_generator_;
-  }
-
-  ~CudaDeviceContext() {
-    Wait();
-    if (blas_handle_) {
-      PADDLE_ENFORCE(
-          paddle::dyload::cublasDestroy(blas_handle_) == CUBLAS_STATUS_SUCCESS,
-          "cublasDestroy failed");
-    }
-
-    if (dnn_handle_) {
-      PADDLE_ENFORCE(
-          paddle::dyload::cudnnDestroy(dnn_handle_) == CUDNN_STATUS_SUCCESS,
-          "cudnnDestroy failed");
-    }
-
-    if (rand_generator_) {
-      PADDLE_ENFORCE(paddle::dyload::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

paddle/platform/device_context_test.cu

-/* 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(DeviceContext, CudaDevice) {
-  int count = paddle::platform::GetDeviceCount();
-  for (int i = 0; i < count; i++) {
-    paddle::platform::CudaDeviceContext* device_context = new paddle::platform::CudaDeviceContext(i);
-    __attribute__((unused)) Eigen::GpuDevice gpu_device = device_context->eigen_device();
-    __attribute__((unused)) cudnnHandle_t cudnn_handle = device_context->cudnn_handle();
-    __attribute__((unused)) cublasHandle_t cublas_handle = device_context->cublas_handle();
-    __attribute__((unused)) curandGenerator_t curand_handle = device_context->curand_generator();
-    delete device_context;
-  }
-}