Kernel 索引、边界与 grid-stride loop

启动形状和问题形状不同

GPU kernel 的启动配置描述多少个 block、每个 block 多少线程；问题本身描述有多少有效元素。两者不必完全相等。设 n=10、block 大小 B=4，需要三个 block，共启动十二个线程。全局下标 i=block_id*B+thread_id 会得到 0 到11，只有前十个可访问数组。i=10、11 的线程不能越界写入，它们仍可能需要参与后续 block 内同步，取决于 kernel 的结构。

需要的 block 数是向上取整 n/B。常见 (n+B-1)/B 在 n 接近整数上限时会先溢出；更稳妥的写法是 n/B + (n%B != 0)，并拒绝 B=0。n=0 时不必发起无效的零网格 launch，host 可以直接按空输入合同返回。真实启动前还要查询设备的每 block 线程数、各维限制和可用资源，不能把教学配置当作通用硬件上限。

一维索引是一种映射合同

第一个例子用嵌套 CPU 循环枚举 block 和 lane，记录每个元素被访问的次数。它不执行 GPU 指令，也不模拟调度；它验证的是索引映射。对一组 n 和 B，检查每个有效元素访问一次，额外线程只执行边界检查。这样的逻辑模型能在没有设备时发现 off-by-one，却无法证明真实 kernel 无 race 或同步错误。

选择整数类型时不要让乘法在窄类型中发生后才转换。应先保证 block_id、B 与问题大小使用足够宽的类型，或先转换再相乘。字节数 n*sizeof(T) 也需检查溢出。64位 host 上的 size_t 与 device 参数布局、API维度类型的关系，要根据具体工具链核实。

grid-stride 改变每线程的工作量

不一定要一个元素对应一个线程。grid-stride loop 让线程先处理自己的初始 i，然后每次增加全网格线程数 S。若 n=17、S=6，线程0处理0、6、12；线程5处理5、11；其余同理。初始余数决定线程归属，因此每个下标恰好归属于一个线程。网格大小可以按设备需要设置，而循环处理更大输入。

这不意味着网格越小越好。线程太少可能不足以隐藏延迟；每线程工作太多可能增加寄存器压力与关键路径。也不能仅因相邻线程的第一次访问连续，就忽略后续循环的依赖和写入冲突。第二例同样是CPU逻辑覆盖检查，没有提供最优block大小建议。

二维与三维要写明布局

行步长与有效坐标（补充，另估15分钟）

先把逻辑列数与行步长分开：row、col是从0起的行列坐标；行主序把一行的有效列依次存放。这里的leading_dimension或行stride表示相邻两行起点相差多少个元素，不是字节数。行尾可以有padding，所以它可以大于逻辑列数。

给定2行×3列、行步长4，并为两行准备8个元素槽：第一行有效偏移0、1、2，偏移3是行尾填充；第二行从4开始，有效偏移4、5、6，偏移7是填充。于是(row=1,col=2)先通过row小于2、col小于3的检查，再算1×4+2=6。坐标(0,3)虽然线性偏移3落在分配范围里，仍不是合法矩阵元素；不能把“地址在缓冲区内”代替“坐标在shape内”。

空的0行或0列形状没有有效坐标，不计算元素访问。对这份非空行主序合同，要保证行步长足够容纳有效列、存储确实覆盖访问偏移，且乘加不溢出；本例的小整数满足这些前提。这里是布局推演，没有执行设备访存；更完整的tensor与转置布局留在第32章。

对于行主序矩阵，元素 (row,col) 对应 row*leading_dimension+col。启动时通常让 x 坐标对应连续的列，y 对应行，但这是一种约定，不是数学强制。二维边界需要分别检查 row 与 col；只比较线性地址可能让越界列落入下一行的合法内存，从而产生“没有崩溃但结果错位”的错误。

向面试官解释索引时先拿一个非常小的非整除尺寸画格子，标出有效线程与多余线程，再写公式。测试包括0、1、B-1、B、B+1和多维边缘。后续共享内存章节会继续说明：没有有效元素的lane可以把单位元写入共享区并参加barrier，不能一律在函数开头return。

输入、边界、状态变化

#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <vector>
std::size_t verify(std::size_t n,std::size_t block) {
    if(block==0) throw std::invalid_argument("block");
    const auto grid=n/block+(n%block!=0?1:0);
    std::vector<int> visits(n,0);
    for(std::size_t b=0;b<grid;++b) for(std::size_t lane=0;lane<block;++lane) {
        const auto i=b*block+lane;if(i<n) ++visits[i];
    }
    for(int count:visits) if(count!=1) throw std::runtime_error("coverage");
    return grid;
}
int main() {
    for(std::size_t n=0;n<=100;++n) for(std::size_t b=1;b<=32;++b) {
        const auto grid=verify(n,b);
        if(grid*b<n || (grid>0 && (grid-1)*b>=n))
            throw std::runtime_error("minimal covering grid");
    }
    bool rejected=false;
    try {
        const auto unexpected=verify(1,0);
        std::cout<<"unexpected zero-block grid="<<unexpected<<'\n';
        return 1;
    } catch(const std::invalid_argument&){rejected=true;}
    if(!rejected || verify(10,4)!=3) throw std::runtime_error("launch");
    std::cout<<"grid=3 launched=12 active=10\n";
}

clang++ -std=c++20 -Wall -Wextra -Wpedantic -Werror -pthread 30-a.cpp -o example && ./example

grid=3 launched=12 active=10

#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <vector>
void verify(std::size_t n,std::size_t threads) {
    if(threads==0) throw std::invalid_argument("threads");
    std::vector<int> visits(n,0);
    for(std::size_t t=0;t<threads;++t) for(std::size_t i=t;i<n;) {
        ++visits[i];if(n-i<=threads) break;i+=threads;
    }
    for(int count:visits) if(count!=1) throw std::runtime_error("grid stride");
}
int main() {
    for(std::size_t n=0;n<=100;++n) for(std::size_t t=1;t<=20;++t) verify(n,t);
    verify(17,6);std::cout<<"thread0=0,6,12 coverage=17\n";
}

clang++ -std=c++20 -Wall -Wextra -Wpedantic -Werror -pthread 30-b.cpp -o example && ./example

thread0=0,6,12 coverage=17