GPU加速之pyCuda快速上手demo

东方耀

GPU加速之pyCuda快速上手demo


官方文档：https://documen.tician.de/pycuda/


快速安装：
pip3 install pycuda


会编译 Building wheel for pycuda (setup.py)


Successfully built pycuda pytools
Installing collected packages: appdirs, dataclasses, pytools, MarkupSafe, mako, pycuda
Successfully installed MarkupSafe-1.1.1 appdirs-1.4.4 dataclasses-0.7 mako-1.1.3 pycuda-2020.1 pytools-2020.4.3

1. # -*- coding: utf-8 -*-
   
2. __author__ = u'东方老师 微信：dfy_88888'
   
3. __date__ = '2020/10/21 下午2:42'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'pycuda_demo01'
   
6. 
   
7. import sys
   
8. from time import time
   
9. from functools import reduce
   
10. 
    
11. import numpy as np
    
12. import pandas as pd
    
13. import matplotlib
    
14. from matplotlib import pyplot as plt
    
15. 
    
16. import pycuda
    
17. import pycuda.autoinit
    
18. import pycuda.driver as drv
    
19. from pycuda import gpuarray
    
20. from pycuda.elementwise import ElementwiseKernel
    
21. from pycuda.scan import InclusiveScanKernel
    
22. from pycuda.reduction import ReductionKernel
    
23. 
    
24. 
    
25. # PyCUDA 可以通过 Python 访问 NVIDIA 的 CUDA 并行计算 API
    
26. 
    
27. print(f'The version of PyCUDA: {pycuda.VERSION}')
    
28. print(f'The version of Python: {sys.version}')
    
29. 
    
30. 
    
31. def query_device():
    
32.     drv.init()
    
33.     print('CUDA device query (PyCUDA version) \n')
    
34.     print(f'Detected {drv.Device.count()} CUDA Capable device(s) \n')
    
35.     for i in range(drv.Device.count()):
    
36. 
    
37.         gpu_device = drv.Device(i)
    
38.         print(f'Device {i}: {gpu_device.name()}')
    
39.         compute_capability = float('%d.%d' % gpu_device.compute_capability())
    
40.         print(f'\t Compute Capability: {compute_capability}')
    
41.         print(f'\t Total Memory: {gpu_device.total_memory() // (1024 ** 2)} megabytes')
    
42. 
    
43.         # The following will give us all remaining device attributes as seen
    
44.         # in the original deviceQuery.
    
45.         # We set up a dictionary as such so that we can easily index
    
46.         # the values using a string descriptor.
    
47. 
    
48.         device_attributes_tuples = gpu_device.get_attributes().items()
    
49.         device_attributes = {}
    
50. 
    
51.         for k, v in device_attributes_tuples:
    
52.             device_attributes[str(k)] = v
    
53. 
    
54.         num_mp = device_attributes['MULTIPROCESSOR_COUNT']
    
55. 
    
56.         # Cores per multiprocessor is not reported by the GPU!
    
57.         # We must use a lookup table based on compute capability.
    
58.         # See the following:
    
59.         # http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities
    
60. 
    
61.         cuda_cores_per_mp = {5.0: 128, 6.0: 64, 6.1: 128, 6.2: 128, 7.5: 128}[compute_capability]
    
62. 
    
63.         print(
    
64.             f'\t ({num_mp}) Multiprocessors, ({cuda_cores_per_mp}) CUDA Cores / Multiprocessor: {num_mp * cuda_cores_per_mp} CUDA Cores')
    
65. 
    
66.         # device_attributes.pop('MULTIPROCESSOR_COUNT')
    
67. 
    
68.         for k in device_attributes.keys():
    
69.             print(f'\t {k}: {device_attributes[k]}')
    
70. 
    
71. 
    
72. # query_device()   # 查询设备
    
73. 
    
74. # NumPy array 和 gpuarray 之间的相互转换
    
75. # GPU 有自己的显存，这区别于主机上的内存，这又称为设备内存（device memory）。
    
76. #
    
77. # NumPy array 运行在 CPU 环境（主机端），而 gpuarray 运行在 GPU 环境（设备端），
    
78. # 两者常常需要相互转换，即 CPU 数据和 GPU 数据之间的传输转换。
    
79. 
    
80. host_data = np.array([1, 2, 3, 4, 5], dtype=np.float32)
    
81. device_data = gpuarray.to_gpu(host_data)
    
82. device_data_x2 = 2 * device_data
    
83. print("设备端数据：", device_data_x2, type(device_data_x2))
    
84. host_data_x2 = device_data_x2.get()
    
85. print("主机端数据：", host_data_x2, type(host_data_x2))
    
86. 
    
87. 
    
88. # 按元素运算是天生的可并行计算的操作类型，在进行这种运算时 gpuarray 会自动利用多核进行并行计算
    
89. # 进行转换的时候应该尽可能通过 dtype 指定类型，以避免不必要的性能损失
    
90. 
    
91. # 性能比较
    
92. def simple_speed_test():
    
93.     host_data = np.float32(np.random.random(50000000))
    
94.     t1 = time()
    
95.     host_data_2x = host_data * np.float32(2)
    
96.     t2 = time()
    
97. 
    
98.     print(f'total time to compute on CPU: {t2 - t1}')
    
99. 
    
100.     device_data = gpuarray.to_gpu(host_data)
     
101. 
     
102.     t1 = time()
     
103.     device_data_2x = device_data * np.float32(2)
     
104.     t2 = time()
     
105. 
     
106.     from_device = device_data_2x.get()
     
107. 
     
108.     print(f'total time to compute on GPU: {t2 - t1}')
     
109.     print(f'Is the host computation the same as the GPU computation? : {np.allclose(from_device, host_data_2x)}')
     
110. 
     
111. 
     
112. # simple_speed_test()
     
113. 
     
114. # Python 的内置函数 map
     
115. print(list(map(lambda x: x + 10, [1, 2, 3, 4, 5])))
     
116. # ElementWiseKernel 非常类似于 map 函数。
     
117. #
     
118. # ElementwiseKernel 函数可以自定义按元素运算的内核。使用时需要嵌入 CUDA C 的代码。
     
119. #
     
120. # 内核（kernel）在这里可以简单理解为 CUDA 直接运行在 GPU 的函数
     
121. 
     
122. gpu_2x_ker = ElementwiseKernel(
     
123.         arguments="float *in, float *out",
     
124.         operation="out[i] = 2 * in[i];",
     
125.         name="gpu_2x_ker"
     
126.     )
     
127. 
     
128. def elementwise_kernel_example():
     
129.     host_data = np.float32(np.random.random(50000000))
     
130.     t1 = time()
     
131.     host_data_2x = host_data * np.float32(2)
     
132.     t2 = time()
     
133.     print(f'total time to compute on CPU: {t2 - t1}')
     
134. 
     
135.     device_data = gpuarray.to_gpu(host_data)
     
136.     # allocate memory for output
     
137.     device_data_2x = gpuarray.empty_like(device_data)
     
138. 
     
139.     t1 = time()
     
140.     gpu_2x_ker(device_data, device_data_2x)
     
141.     t2 = time()
     
142.     from_device = device_data_2x.get()
     
143.     print(f'total time to compute on GPU: {t2 - t1}')
     
144.     print(f'Is the host computation the same as the GPU computation? : {np.allclose(from_device, host_data_2x)}')
     
145. 
     
146. # 因为在 PyCUDA 中，通常会在程序第一次运行过程中，nvcc 编译器会对 GPU 代码进行编译，
     
147. # 然后由 PyCUDA 进行调用。这个编译时间就是额外的性能损耗
     
148. # nvcc -V
     
149. for _ in range(30):
     
150.     elementwise_kernel_example()
     
151. 
     
152. # class pycuda.elementwise.ElementwiseKernel(arguments, operation, name="kernel", keep=False, options=[], preamble="")
     
153. # arguments：该内核定义的传参
     
154. # operation：该内核定义的内嵌 CUDA C 代码
     
155. # name：定义的内核名称
     
156. 
     
157. # 运行输出之后PyCuda就会把所有清理和内存回收工作做好了，咱们的简介也就完毕了
     
158. 
     

复制代码

bixintao

积分积分积分