CUDA——L1缓存全局内存加载

已知A和B两个数组类型int，尺寸100。现在使用一些thread来将A中的一些元素复制到B中去。通过一些对比，来明确一些基本概念。

L1缓存的载入事务粒度是128字节。

#- 编译中显式开启L1缓存，启动一个warp，加载的数据为128字节，共消耗1个加载事务，利用率100%
nvcc -g -G -Xptxas -dlcm=ca -arch=sm_37 test.cu -o test
nvprof --metrics gld_transactions,gld_efficiency ./test
matrixMulti<<<(1 1 1), (32 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency     100.00%     100.00%     100.00%

#- 编译中显式开启L1缓存，启动一个warp，加载的数据为120字节，共消耗1个加载事务，利用率 120/128=93.75%，说明L1缓存启用时，粒度为128字节
matrixMulti<<<(1 1 1), (1 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency       3.12%       3.12%       3.12%

L2缓存的内存事务粒度为32字节，但是对于载入而言，是可以以一段、二段、三段、四段四种选项来自动适配的。

#- nvcc关闭L1缓存，加载一个4字节的效率为12.5%，说明粒度为32字节
nvcc -g -G -Xptxas -dlcm=cg -arch=sm_37 test.cu -o test
matrixMulti<<<(1 1 1), (1 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency      12.50%      12.50%      12.50%
#- nvcc关闭L1缓存，加载一个36字节的效率为56.25%，说明粒度为64字节
matrixMulti<<<(1 1 1), (9 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency      56.25%      56.25%      56.25%
#- nvcc关闭L1缓存，加载一个68字节的效率为70.83%，说明粒度为96字节
matrixMulti<<<(1 1 1), (17 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency      70.83%      70.83%      70.83%
#- nvcc关闭L1缓存，加载一个100字节的效率为78.12%，说明粒度为128字节
matrixMulti<<<(1 1 1), (25 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           1           1           1
          1                            gld_efficiency             Global Memory Load Efficiency      78.12%      78.12%      78.12%

对齐概念基于的首地址是对应数组的首地址。

#- B[x] = A[x+1]; 偏移1位，启动了2个内存事务，累积有5段32位加载，需要的是4段，因此效率为80%。
nvcc -g -G -Xptxas -dlcm=cg -arch=sm_37 test.cu -o test
matrixMulti<<<(1 1 1), (32 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gld_transactions                  Global Load Transactions           2           2           2
          1                            gld_efficiency             Global Memory Load Efficiency      80.00%      80.00%      80.00%

2. 同时也证明了，L2缓存时，一个内存加载事务最多包含4段32位的加载。
3. 载出只有L2缓存，没有L1缓存

#- 编译中显式开启L1缓存，启动一个warp，加载的数据为128字节，共消耗1个加载事务，利用率100%
#- B[x+1] = A[x]; 偏移1位，启动了2个内存事务，累积有5段32位载出，需要的是4段，因此效率为80%。
nvcc -g -G -Xptxas -dlcm=ca -arch=sm_37 test.cu -o test
matrixMulti<<<(1 1 1), (32 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gst_transactions                 Global Store Transactions           2           2           2
          1                            gst_efficiency            Global Memory Store Efficiency      80.00%      80.00%      80.00%
#- 编译中显式开启L1缓存
matrixMulti<<<(1 1 1), (24 1 1)>>> execute
Invocations                               Metric Name                        Metric Description         Min         Max         Avg
Device "Tesla K80 (4)"
        Kernel: matrixMulti(int*, int*)
          1                          gst_transactions                 Global Store Transactions           1           1           1
          1                            gst_efficiency            Global Memory Store Efficiency     100.00%     100.00%     100.00%

例子

#- C[x] = A[3] + B[x]; 禁用L1缓存

• 错误计算：由于禁用了L1，那么L2的粒度为32。一个warp内的32个线程都需要对A和B各自访问一次，因此效率为两者的平均值：$(4/32+1)/2=56.25$。
• 正确计算：由于warp内的32个线程访问同一个A元素（4字节），访问连续对其的B元素（128字节），那么L2对于A的访问会启用一段32字节的事务，而对B则会启用4段32字节的事务，因此两个事务总共加载了160字节。而有效数据为132字节，因此效率为82.5%。