gpu_info.cc 5.3 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
L
liaogang 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14

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. */

Y
Yi Wang 已提交
15
#include "paddle/fluid/platform/gpu_info.h"
L
liaogang 已提交
16

17
#include <algorithm>
L
liaogang 已提交
18

19
#include "gflags/gflags.h"
Y
Yi Wang 已提交
20
#include "paddle/fluid/platform/enforce.h"
L
liaogang 已提交
21

22 23
DEFINE_double(fraction_of_gpu_memory_to_use, 0.92,
              "Default use 92% of GPU memory for PaddlePaddle,"
L
liaogang 已提交
24 25 26 27 28
              "reserve the rest for page tables, etc");

namespace paddle {
namespace platform {

29
int GetCUDADeviceCount() {
L
liaogang 已提交
30
  int count;
L
liaogang 已提交
31
  PADDLE_ENFORCE(
L
liaogang 已提交
32
      cudaGetDeviceCount(&count),
33
      "cudaGetDeviceCount failed in paddle::platform::GetCUDADeviceCount");
L
liaogang 已提交
34 35 36
  return count;
}

37 38 39 40 41 42 43 44 45
int GetCUDAComputeCapability(int id) {
  PADDLE_ENFORCE_LT(id, GetCUDADeviceCount(), "id must less than GPU count");
  cudaDeviceProp device_prop;
  PADDLE_ENFORCE(cudaGetDeviceProperties(&device_prop, id),
                 "cudaGetDeviceProperties failed in "
                 "paddle::platform::GetCUDAComputeCapability");
  return device_prop.major * 10 + device_prop.minor;
}

C
chengduoZH 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
int GetCUDAMultiProcessors(int id) {
  PADDLE_ENFORCE_LT(id, GetCUDADeviceCount(), "id must less than GPU count");
  int count;
  PADDLE_ENFORCE(
      cudaDeviceGetAttribute(&count, cudaDevAttrMultiProcessorCount, id),
      "cudaDeviceGetAttribute failed in "
      "paddle::platform::GetCUDAMultiProcessors");
  return count;
}

int GetCUDAMaxThreadsPerMultiProcessor(int id) {
  PADDLE_ENFORCE_LT(id, GetCUDADeviceCount(), "id must less than GPU count");
  int count;
  PADDLE_ENFORCE(cudaDeviceGetAttribute(
                     &count, cudaDevAttrMaxThreadsPerMultiProcessor, id),
                 "cudaDeviceGetAttribute failed in "
                 "paddle::platform::GetCUDAMaxThreadsPerMultiProcessor");
  return count;
}

L
liaogang 已提交
66 67
int GetCurrentDeviceId() {
  int device_id;
L
liaogang 已提交
68
  PADDLE_ENFORCE(
L
liaogang 已提交
69 70 71 72 73 74
      cudaGetDevice(&device_id),
      "cudaGetDevice failed in paddle::platform::GetCurrentDeviceId");
  return device_id;
}

void SetDeviceId(int id) {
Q
qijun 已提交
75
  // TODO(qijun): find a better way to cache the cuda device count
Y
Yang Yang 已提交
76
  PADDLE_ENFORCE_LT(id, GetCUDADeviceCount(), "id must less than GPU count");
L
liaogang 已提交
77
  PADDLE_ENFORCE(cudaSetDevice(id),
L
liaogang 已提交
78 79 80
                 "cudaSetDevice failed in paddle::platform::SetDeviceId");
}

81 82
void GpuMemoryUsage(size_t *available, size_t *total) {
  PADDLE_ENFORCE(cudaMemGetInfo(available, total),
L
liaogang 已提交
83 84 85 86 87 88 89
                 "cudaMemGetInfo failed in paddle::platform::GetMemoryUsage");
}

size_t GpuMaxAllocSize() {
  size_t total = 0;
  size_t available = 0;

90
  GpuMemoryUsage(&available, &total);
L
liaogang 已提交
91

L
liaogang 已提交
92
  // Reserve the rest for page tables, etc.
L
liaogang 已提交
93
  return static_cast<size_t>(total * FLAGS_fraction_of_gpu_memory_to_use);
L
liaogang 已提交
94 95
}

L
liaogang 已提交
96 97 98 99 100 101 102
size_t GpuMinChunkSize() {
  // Allow to allocate the minimum chunk size is 256 bytes.
  return 1 << 8;
}

size_t GpuMaxChunkSize() {
  size_t total = 0;
103
  size_t available_memory = 0;
L
liaogang 已提交
104

105 106
  GpuMemoryUsage(&available_memory, &total);
  VLOG(10) << "GPU Usage " << available_memory / 1024 / 1024 << "M/"
107 108
           << total / 1024 / 1024 << "M";
  size_t reserving = static_cast<size_t>(0.05 * total);
L
liaogang 已提交
109
  // If available less than minimum chunk size, no usable memory exists.
110 111 112
  available_memory = std::min(
      std::max(available_memory, GpuMinChunkSize()) - GpuMinChunkSize(),
      total - reserving);
113 114

  // Reserving the rest memory for page tables, etc.
L
liaogang 已提交
115

116 117
  size_t allocating_memory = static_cast<size_t>(
      FLAGS_fraction_of_gpu_memory_to_use * (total - reserving));
L
liaogang 已提交
118

119
  PADDLE_ENFORCE_LE(allocating_memory, available_memory);
120

121
  return allocating_memory;
L
liaogang 已提交
122 123
}

L
liaogang 已提交
124 125
void GpuMemcpyAsync(void *dst, const void *src, size_t count,
                    enum cudaMemcpyKind kind, cudaStream_t stream) {
L
liaogang 已提交
126 127
  PADDLE_ENFORCE(cudaMemcpyAsync(dst, src, count, kind, stream),
                 "cudaMemcpyAsync failed in paddle::platform::GpuMemcpyAsync");
L
liaogang 已提交
128 129
}

130 131 132 133 134 135 136 137
void GpuMemcpySync(void *dst, const void *src, size_t count,
                   enum cudaMemcpyKind kind) {
  PADDLE_ENFORCE(cudaMemcpy(dst, src, count, kind),
                 "cudaMemcpy failed in paddle::platform::GpuMemcpySync");
}

void GpuMemcpyPeerAsync(void *dst, int dst_device, const void *src,
                        int src_device, size_t count, cudaStream_t stream) {
L
liaogang 已提交
138
  PADDLE_ENFORCE(
L
liaogang 已提交
139
      cudaMemcpyPeerAsync(dst, dst_device, src, src_device, count, stream),
140 141 142 143 144 145 146 147
      "cudaMemcpyPeerAsync failed in paddle::platform::GpuMemcpyPeerAsync");
}

void GpuMemcpyPeerSync(void *dst, int dst_device, const void *src,
                       int src_device, size_t count) {
  PADDLE_ENFORCE(
      cudaMemcpyPeer(dst, dst_device, src, src_device, count),
      "cudaMemcpyPeer failed in paddle::platform::GpuMemcpyPeerSync");
L
liaogang 已提交
148
}
D
dzhwinter 已提交
149 150 151 152 153

void GpuMemsetAsync(void *dst, int value, size_t count, cudaStream_t stream) {
  PADDLE_ENFORCE(cudaMemsetAsync(dst, value, count, stream),
                 "cudaMemsetAsync failed in paddle::platform::GpuMemsetAsync");
}
L
liaogang 已提交
154 155
}  // namespace platform
}  // namespace paddle