C++ OpenCL内核没有'；我不能被处决

有一组规则，其中每个规则对应于ceratain细胞自动机。我需要检查每个规则的双射性属性。由于它们太多了（准确地说是2^32），我决定使用我的GPU来实现这个目的。但大约一周后，我仍在与一个bug作斗争。
简单地说，当内核排队时，它的执行应该在GPU上执行，GPU的使用就好像它是空闲的一样。此外，在我向内核代码中添加了几个语句以查看内核是否正在执行之后，我发现没有任何迹象表明这些语句以及内核本身已经执行。此外，所有错误代码都等于CL_成功。我可能会出错，因为我是OpenCL编程新手，非常感谢您的帮助。
这是主机端代码，带有一些缩写：

#define CL_USE_DEPRECATED_OPENCL_2_0_APIS

//some includes here

#define GLOBAL_SIZE 4096
#define LOCAL_SIZE 256
#define GLOBAL_SCOPE 0xffffffff
int main()
{
    //we assume that global_scope divides evenly into global_size
    //and therefore there is no need in processing remainder
    long rules_per_thread = GLOBAL_SCOPE / GLOBAL_SIZE;
    
    int * starts = new int[GLOBAL_SIZE];
    int * stops = new int[GLOBAL_SIZE];

    int count = 0;
    for (int i = 0; i < GLOBAL_SIZE; i++) {
        starts[i] = count;
        count += rules_per_thread;
        stops[i] = count;
        count++;
    }
    
    ...
    /*obtainig platform, device, building program*/
    ...

    /*====CREATING BUFFERS====*/
    //buffer for storing approved automata
    const int bufSize = 10000;  //size of buffer picked at random guess; might need to add some space later
    uint32_t* bijective_aut = new uint32_t[bufSize];
    std::fill(&bijective_aut[0], &bijective_aut[bufSize - 1], 0);
    //first value in array serves as global iterator over array
    //and initially is set to base offset
    bijective_aut[0] = 3;
    //second value serves as indicator of array length
    bijective_aut[1] = bufSize;

    cl::Buffer buf(context, CL_MEM_READ_WRITE, sizeof(uint32_t) * bufSize);
    cl::Buffer starts_buf(context, CL_MEM_READ_ONLY, sizeof(int) * GLOBAL_SIZE);
    cl::Buffer stops_buf(context, CL_MEM_READ_ONLY, sizeof(int) * GLOBAL_SIZE);

    /*====SETTING UP COMMAND QUEUE====*/
    cl::CommandQueue queue(context, device);

    err = queue.enqueueWriteBuffer(buf, CL_FALSE, 0, sizeof(uint32_t) * bufSize, bijective_aut);
    err = queue.enqueueWriteBuffer(starts_buf, CL_FALSE, 0, sizeof(int) * GLOBAL_SIZE, starts);
    err = queue.enqueueWriteBuffer(stops_buf, CL_FALSE, 0, sizeof(int) * GLOBAL_SIZE, stops);

    /*====CREATING KERNEL, SETTING ITS VARIABLES====*/
    cl::Kernel bc_kernel(program, "bijection_check", &err);
    err = bc_kernel.setArg(0, buf);
    err = bc_kernel.setArg(1, starts_buf);
    err = bc_kernel.setArg(2, stops_buf);

    /*====EXECUTING KERNEL====*/
    cl::Event event;
    err = queue.enqueueNDRangeKernel(bc_kernel, cl::NullRange, cl::NDRange(GLOBAL_SIZE), cl::NDRange(LOCAL_SIZE), nullptr, &event);
    event.wait();
    err = queue.enqueueReadBuffer(buf, CL_FALSE, 0, sizeof(uint32_t) * bufSize, bijective_aut);
    cl::finish();

}

\define CL\u USE\u DEPRECATED\u OPENCL\u 2\u 0\u API
//有些包括在这里
#定义全局_大小4096
#定义本地_大小256
#定义全局范围0xffffffff
int main（）
{
//我们假设全局_范围平均划分为全局_大小
//因此，不需要处理剩余部分
每个线程的长规则=全局范围/全局大小；
int*开始=新的int[全局大小]；
int*stops=newint[GLOBAL_SIZE]；
整数计数=0；
对于（int i=0；i

然后是内核代码：

 __kernel void bijection_check (
                                __global uint * bijective_rules, //stores approved bijective rules
                                __global const uint * starts, 
                                __global const uint * stops 
                              ) 
{
    __private int idx = get_global_id(0);
    int iterator = bijective_rules[0];  //inditates next free cell to write in
    int start = starts[idx];
    int stop = stops[idx];
    bool check = true;
    //there is some variables required for test

    //iterating over rules between *start* and *stop*
    for (uint rule = start; rule < stop; rule++)
    {
        ...
        /*then there goes test of the rule for bijectivity*/
        ...

        //writing current rule to general list if it turned to be bijective
        if ((check == true) && (iterator < 10000))
        {
            bijective_rules[iterator] = rule;
            bijective_rules[0]++;
        }
        else
        {
            bijective_rules[2]++;
        }
    }
    bijective_rules[3]++;
}

\u内核无效双射\u检查(
__全局uint*双射_规则，//存储批准的双射规则
__全局consuint*开始，
__全局consuint*停止
) 
{
__private int idx=get\u global\u id（0）；
int迭代器=双射_规则[0]；//指示下一个要写入的空闲单元格
int start=start[idx]；
int-stop=stops[idx]；
布尔检查=真；
//测试需要一些变量
//在*开始*和*停止*之间迭代规则*
对于（uint规则=开始；规则<停止；规则++）
{
...
/*然后对双射性规则进行了检验*/
...
//如果当前规则变为双射，则将其写入常规列表
if（（check==true）&&（迭代器<10000））
{
双射_规则[迭代器]=规则；
双射_规则[0]+；
}
其他的
{
双射_规则[2]+；
}
}
双射_规则[3]+；
}

---

根据执行后从缓冲区读取的数组判断，最后的两条语句都没有一次执行。也就是说，在内核执行之后，双射_规则数组的状态与以前在主机端定义的完全相同。

您有一个竞争条件：您读取

双射_规则[0]

，但其他线程可能同时执行

双射_规则[0]++，从而读取和写入该内存位置。如果两个线程将不同的数据写入同一个内存地址，则存在竞争条件，这两个线程中的哪一个将随机决定结果。因此，您的结果将是随机和不可复制的

如果多个线程需要在同一内存位置增加一个值，请使用atoimic函数。原子函数在一个线程运行时阻塞内存位置，而所有其他线程都必须等待

要消除竞争条件，请从缓冲区的一个副本（或一个特定内存地址）读取，然后写入第二个副本（或地址）。这样，您就不会写入其他并发线程正在读取的内存。
谢谢您的回复！这绝对是我自己不会发现的问题。但我不确定这是否是导致程序奇怪行为的唯一原因。