gpu_info.cc 5.9 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"
16

17
#include <algorithm>
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;
}

66 67
int GetCurrentDeviceId() {
  int device_id;
L
liaogang 已提交
68
  PADDLE_ENFORCE(
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),
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 = 0;
L
liaogang 已提交
104

105 106
  GpuMemoryUsage(&available, &total);
  VLOG(10) << "GPU Usage " << available / 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 =
      std::min(std::max(available, GpuMinChunkSize()) - GpuMinChunkSize(),
               total - reserving);
113 114

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

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

119 120
  PADDLE_ENFORCE_LE(allocating, available,
                    "Insufficient GPU memory to allocation.");
121

122
  return allocating;
L
liaogang 已提交
123 124
}

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

131 132 133 134 135 136 137 138
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 已提交
139
  PADDLE_ENFORCE(
140
      cudaMemcpyPeerAsync(dst, dst_device, src, src_device, count, stream),
141 142 143 144 145 146 147 148
      "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 已提交
149
}
150 151 152 153 154

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");
}
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171

std::tuple<int, int, int> GpuMaxGridDim(int id) {
  std::tuple<int, int, int> result;
  PADDLE_ENFORCE(
      cudaDeviceGetAttribute(&std::get<0>(result), cudaDevAttrMaxBlockDimX, id),
      "cudaDeviceGetAttribute failed in "
      "cudaDevAttrMaxBlockDim");
  PADDLE_ENFORCE(
      cudaDeviceGetAttribute(&std::get<1>(result), cudaDevAttrMaxBlockDimY, id),
      "cudaDeviceGetAttribute failed in "
      "cudaDevAttrMaxBlockDim");
  PADDLE_ENFORCE(
      cudaDeviceGetAttribute(&std::get<2>(result), cudaDevAttrMaxBlockDimZ, id),
      "cudaDeviceGetAttribute failed in "
      "cudaDevAttrMaxBlockDim");
  return result;
}
L
liaogang 已提交
172 173
}  // namespace platform
}  // namespace paddle
反馈
建议
客服 返回
顶部