CUDA页锁定内存（Pinned Memory）

对CUDA架构而言，主机端的内存被分为两种，一种是可分页内存（pageable memroy）和页锁定内存（page-lock或 pinned）。可分页内存是由操作系统API malloc()在主机上分配的，页锁定内存是由CUDA函数cudaHostAlloc()在主机内存上分配的，页锁定内存的重要属性是主机的操作系统将不会对这块内存进行分页和交换操作，确保该内存始终驻留在物理内存中。

GPU知道页锁定内存的物理地址，可以通过“直接内存访问（Direct Memory Access，DMA）”技术直接在主机和GPU之间复制数据，速率更快。由于每个页锁定内存都需要分配物理内存，并且这些内存不能交换到磁盘上，所以页锁定内存比使用标准malloc()分配的可分页内存更消耗内存空间。

页锁定内存的内配、操作和可分页内存的对比：

[cpp]  view plain  copy

1. #include "cuda_runtime.h"  
2. #include "device_launch_parameters.h"  
3. #include "iostream"  
4. #include <stdio.h>  
5.   
6. using namespace std;  
7.   
8. float cuda_host_alloc_test(int size, bool up)  
9. {  
10.     //耗时统计  
11.     cudaEvent_t start, stop;  
12.     float elapsedTime;  
13.     cudaEventCreate(&start);  
14.     cudaEventCreate(&stop);  
15.   
16.     int *a, *dev_a;  
17.   
18.     //在主机上分配页锁定内存  
19.     cudaError_t cudaStatus = cudaHostAlloc((void **)&a, size * sizeof(*a), cudaHostAllocDefault);  
20.     if (cudaStatus != cudaSuccess)  
21.     {  
22.         printf("host alloc fail!\n");  
23.         return -1;  
24.     }  
25.   
26.     //在设备上分配内存空间  
27.     cudaStatus = cudaMalloc((void **)&dev_a, size * sizeof(*dev_a));  
28.     if (cudaStatus != cudaSuccess)  
29.     {  
30.         fprintf(stderr, "cudaMalloc failed!\n");  
31.         return -1;  
32.     }  
33.   
34.     //计时开始  
35.     cudaEventRecord(start, 0);  
36.   
37.     for (int i = 0; i < 100; i++)  
38.     {  
39.   
40.         //从主机到设备复制数据  
41.         cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(*dev_a), cudaMemcpyHostToDevice);  
42.         if (cudaStatus != cudaSuccess)  
43.         {  
44.             fprintf(stderr, "cudaMemcpy Host to Device failed!\n");  
45.             return -1;  
46.         }  
47.   
48.         //从设备到主机复制数据  
49.         cudaStatus = cudaMemcpy(a, dev_a, size * sizeof(*dev_a), cudaMemcpyDeviceToHost);  
50.         if (cudaStatus != cudaSuccess)  
51.         {  
52.             fprintf(stderr, "cudaMemcpy Device to Host failed!\n");  
53.             return -1;  
54.         }  
55.     }  
56.     cudaEventRecord(stop, 0);  
57.     cudaEventSynchronize(stop);  
58.     cudaEventElapsedTime(&elapsedTime, start, stop);  
59.   
60.     cudaFreeHost(a);  
61.     cudaFree(dev_a);  
62.     cudaEventDestroy(start);  
63.     cudaEventDestroy(stop);  
64.   
65.     return (float)elapsedTime / 1000;  
66.   
67. }  
68.   
69. float cuda_host_Malloc_test(int size, bool up)  
70. {  
71.     //耗时统计  
72.     cudaEvent_t start, stop;  
73.     float elapsedTime;  
74.     cudaEventCreate(&start);  
75.     cudaEventCreate(&stop);  
76.   
77.     int *a, *dev_a;  
78.   
79.     //在主机上分配可分页内存  
80.     a = (int*)malloc(size * sizeof(*a));  
81.   
82.     //在设备上分配内存空间  
83.     cudaError_t cudaStatus = cudaMalloc((void **)&dev_a, size * sizeof(*dev_a));  
84.     if (cudaStatus != cudaSuccess)  
85.     {  
86.         fprintf(stderr, "cudaMalloc failed!\n");  
87.         return -1;  
88.     }  
89.   
90.     //计时开始  
91.     cudaEventRecord(start, 0);  
92.   
93.     for (int i = 0; i < 100; i++)  
94.     {  
95.   
96.         //从主机到设备复制数据  
97.         cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(*dev_a), cudaMemcpyHostToDevice);  
98.         if (cudaStatus != cudaSuccess)  
99.         {  
100.             fprintf(stderr, "cudaMemcpy Host to Device failed!\n");  
101.             return -1;  
102.         }  
103.   
104.         //从设备到主机复制数据  
105.         cudaStatus = cudaMemcpy(a, dev_a, size * sizeof(*dev_a), cudaMemcpyDeviceToHost);  
106.         if (cudaStatus != cudaSuccess)  
107.         {  
108.             fprintf(stderr, "cudaMemcpy Device to Host failed!\n");  
109.             return -1;  
110.         }  
111.     }  
112.     cudaEventRecord(stop, 0);  
113.     cudaEventSynchronize(stop);  
114.     cudaEventElapsedTime(&elapsedTime, start, stop);  
115.   
116.     free(a);  
117.     cudaFree(dev_a);  
118.     cudaEventDestroy(start);  
119.     cudaEventDestroy(stop);  
120.   
121.     return (float)elapsedTime / 1000;  
122. }  
123.   
124. int main()  
125. {  
126.     float allocTime = cuda_host_alloc_test(100000, true);  
127.     cout << "页锁定内存: " << allocTime << " s" << endl;  
128.     float mallocTime = cuda_host_Malloc_test(100000, true);  
129.     cout << "可分页内存: " << mallocTime << " s" << endl;  
130.     getchar();  
131.     return 0;  
132. }  

对比效果，页锁定内存的访问时间约为可分页内存的访问时间的一半：