C++ OpenCL代码卡在写输出缓冲区上

C++ OpenCL代码卡在写输出缓冲区上,c++,debugging,opencl,C++,Debugging,Opencl,我在OpenCL中有这样的代码和平: std::string src = "__kernel void dot_product(__global float* weights," "__global float* values," "__global

我在OpenCL中有这样的代码和平:

            std::string src = "__kernel void dot_product(__global float* weights,"
                                                        "__global float* values,"
                                                        "__global float* result,"
                                                        "__const unsigned int sz){"
                                "float dot = 0.f;"
                                "unsigned int i;"
                                "int current_idx = get_global_id(0);"
                                "unsigned int offset = current_idx * sz;"
                                "for( i = 0; i < sz; ++i )"
                                "{"
                                    "dot += weights[ offset + i ] * values[ offset + i ];"
                                "}"
                                "result[current_idx] = dot;"
                              "}";
std::string src=“\uuuuu内核无效点积(\uuuu全局浮点*权重,”
“全局浮点*值,”
“全局浮点*结果,”
“_const unsigned int sz{”
“浮点数=0.f;”
“无符号整数i;”
“int current_idx=get_global_id(0);”
“无符号整数偏移量=当前_idx*sz;”
“对于(i=0;i
在结果[current_idx]=dot时卡住;如果我注释掉这段代码,一切都很好。 我不明白为什么它会堆积起来

<相关的C++代码在这里:

               using namespace cl;      
                std::array< float, CONST_INPUTS_NUMBER * CONST_NEURONS_NUMBER > in_weights;      
                std::array< float, CONST_INPUTS_NUMBER * CONST_NEURONS_NUMBER > in_values;      
                // Create a command queue and use the first device      
                const std::size_t size = in_weights.size();      
                std::vector< Device > devices =      
                 m_context.getInfo< CL_CONTEXT_DEVICES >();      
                Buffer weights(m_context, CL_MEM_READ_ONLY, size * sizeof(float));      
                Buffer values(m_context, CL_MEM_READ_ONLY, size * sizeof(float));      
                Buffer product(m_context, CL_MEM_WRITE_ONLY, CONST_NEURONS_NUMBER * sizeof(float));      

                std::cout << __FILE__ << __LINE__ << std::endl;      

                // Set arguments to kernel      
                m_kernel.setArg(0, weights);      
                m_kernel.setArg(1, values);      
                m_kernel.setArg(2, product);      
                m_kernel.setArg(3, CONST_INPUTS_NUMBER);      
                CommandQueue queue(m_context, devices[0]);      

                try {        
                    std::vector< float > dotProducts(CONST_NEURONS_NUMBER);      
                    for(std::size_t i = 0; i < CONST_NEURONS_NUMBER; ++i) {      
                        // Create memory buffers      
                        for(std::size_t j = 0; j < CONST_INPUTS_NUMBER; ++j) {      
                            const std::size_t index = i * CONST_INPUTS_NUMBER + j;      
                            in_weights[index] = m_internal[i][j].weight;      
                            in_values[index] = m_internal[i][j].value;      
                        }      
                    }        

                    queue.enqueueWriteBuffer(weights,      
                                             CL_TRUE,      
                                             0,      
                                             in_weights.size() * sizeof(float),      
                                             in_weights.data());      
                    queue.enqueueWriteBuffer(values,      
                                             CL_TRUE,      
                                             0,      
                                             in_values.size() * sizeof(float),      
                                             in_values.data());      
                    for(std::size_t offset = 0; offset < CONST_NEURONS_NUMBER; ++offset) {      
                        queue.enqueueNDRangeKernel(m_kernel,      
                                                   cl::NDRange(offset),      
                                                   cl::NDRange(CONST_INPUTS_NUMBER));      
                    }        

                    std::cout << __FILE__ << __LINE__ << std::endl;      
                    queue.enqueueReadBuffer(product,      
                                            CL_TRUE,      
                                            0,      
                                            CONST_NEURONS_NUMBER * sizeof(float),      
                                            dotProducts.data());      

                    std::cout << __FILE__ << __LINE__ << std::endl;      
                    for(std::size_t i = 0; i < CONST_NEURONS_NUMBER; ++i) {      
                        std::cout << __FILE__ << __LINE__ << std::endl;      
                        m_internal[i].calculateOutput(dotProducts.begin(),      
                                                      dotProducts.end());      
                    }        
                } catch(const cl::Error& e) {      
                    cl_int err;      
                    cl::STRING_CLASS buildlog =      
                     m_program.getBuildInfo< CL_PROGRAM_BUILD_LOG >(devices[0], &err);      
                    std::cout << "Building error! Log: " << buildlog << std::endl;    
                }            
使用名称空间cl;
std::数组<浮点,常量输入\数量*常量神经元\数量>单位权重;
std::数组<浮点,常量输入\数值*常量神经元\数值>输入\数值;
//创建命令队列并使用第一个设备
常数std::size_t size=in_weights.size();
标准::向量<设备>设备=
m_context.getInfo();
缓冲区权重(m_上下文、CL_MEM_只读、大小*大小(浮点));
缓冲区值(m_上下文、CL_MEM_只读、大小*sizeof(float));
缓冲区产品(m_上下文、CL_MEM_WRITE_ONLY、常量编号*sizeof(float));
标准::cout
在结果[current_idx]=dot时卡住;如果我把这个评论掉
代码一切工作正常。我不明白为什么它会堆积起来

当您注释掉将计算结果写入输出缓冲区的行时,优化器很可能会删除所有计算,而将内核留空

我认为问题出在这里:

for(std::size_t offset = 0; offset < CONST_NEURONS_NUMBER; ++offset) {      
    queue.enqueueNDRangeKernel(m_kernel, cl::NDRange(offset), cl::NDRange(CONST_INPUTS_NUMBER));      
} 

CONST\u INPUTS\u NUMBER
已作为内核参数传递。

仅此一点并不能解决我的问题,但是向队列添加一个附加参数。enqueueNDRangeKernel值为20或255的本地范围(而不是默认参数NullRange)解决了问题。我不明白为什么会这样。啊,很抱歉,这并不能真正解决问题。然后我得到一个例外。
queue.enqueueNDRangeKernel(m_kernel, cl::NullRange, cl::NDRange(CONST_NEURONS_NUMBER));