Question

我在2D阵列上执行5点模板操作，直到获得在此2D阵列上计算的收敛。所以我有多次迭代（直到收敛），并且对于每次迭代，我调用clEnqueueNDRangeKernel函数来计算2D输入数组的新值。

实际上，我操纵一维数组，因为内核代码不支持2D（至少，我相信）。

我的问题是我不知道如何在输出和输入数组之间进行操作。在计算迭代（模板操作）之后，我想将输出分配给下一次迭代的输入。

但我对如何实现这一点感到困惑。

在我的主循环中使用的函数下面：

while(!convergence)
    {
      step = step + 1;

      Compute_Stencil(command_queue, global_item_size, local_item_size, kernel, x0_mem_obj, x_mem_obj, r_mem_obj, x_input, r, size_x, size_y, &error) ;

      convergence = sqrt(error);

      if ((convergence<epsilon) || (step>maxStep)) break;
    }

其中x0_mem_obj是与x_input数组关联的缓冲区，而x_mem_obj与x_ouput数组关联。

以及我感兴趣的Compute_Stencil函数：

void Compute_Stencil(cl_command_queue command_queue, size_t* global_item_size, size_t* local_item_size, cl_kernel kernel, cl_mem x0_mem_obj, cl_mem x_mem_obj, cl_mem r_mem_obj, double* x, double* r, int size_x, int size_y, double* error)
{

status = clEnqueueNDRangeKernel(command_queue, kernel, 2, NULL,
        global_item_size, local_item_size, 0, NULL, NULL);

 // Read the buffer back to the array
  if(clEnqueueReadBuffer(command_queue, x_mem_obj, CL_TRUE, 0,
        (size_x+2) * (size_y+2) * sizeof(double), x, 0, NULL, NULL) != CL_SUCCESS)
    fprintf(stderr,"Error in clEnqueueReadBuffer with x_mem_obj\n");


  if(clEnqueueReadBuffer(command_queue, r_mem_obj, CL_TRUE, 0,
        (size_x+2) * (size_y+2) * sizeof(double), r, 0, NULL, NULL) != CL_SUCCESS)
    fprintf(stderr,"Error in clEnqueueReadBuffer with r_mem_obj\n");


  status = clFlush(command_queue);
  if(status)
  {fprintf(stderr,"Failed to flush command Queue\n");
    exit(-1);}

  if(clEnqueueWriteBuffer(command_queue, x0_mem_obj, CL_TRUE, 0,
        (size_x+2) * (size_y+2) * sizeof(cl_double), x, 0, NULL, NULL) != CL_SUCCESS)
    fprintf(stderr,"Error in clEnqueueWriteuffer with x0_mem_obj\n");

 // Set new Argument - Outputs become Inputs
  status = clSetKernelArg(
      kernel,
      5,
      sizeof(cl_mem),
      (void*)&x0_mem_obj);

...

我认为这不是最好的方法，因为对于每次迭代，我必须将输出x_mem_obj缓冲区读取到x_input（使用clEnqueueReadBuffer）并将x_input写入x0_mem_obj缓冲区（带clEnqueueWWriteBuffer）并最终将x0_mem_obj缓冲区设置为kernelArg（第5个参数）：此缓冲区表示main中的输入x0_mem_obj：

ret = clSetKernelArg(kernel, 5, sizeof(cl_mem), (void *)&x0_mem_obj);

我认为这不是一个好方法，因为性能非常糟糕（我认为读写缓冲区操作需要花费很多时间）。

我尽量不在Compute_Stencil函数中使用ReadBuffer和WriteBuffer，并将输出缓冲区x_mem_obj直接放在第5个参数中以进行下一次调用：

 status = clEnqueueNDRangeKernel(command_queue, kernel, 2, NULL,
        global_item_size, local_item_size, 0, NULL, NULL);

status = clFlush(command_queue);

// Set new Argument - Outputs become Inputs
  status = clSetKernelArg(
      kernel,
      5,
      sizeof(cl_mem),
      (void*)&x_mem_obj);

但结果无效。

任何人都可以告诉我如何在NDRangeKernel调用之后简单地将输出数组传输到输入数组，以便下次调用NDRangeKernel。

由于

UPDATE1：

@doqtor，谢谢你的答案，但我必须指明，在计算新值之后（即在调用NDRangeKernel之后），我需要将新的计算值分配给输入，但我想我不知道需要通过输出1替换输入数组：输出缓冲区将被从输入缓冲区值计算的新值系统地覆盖。

在我的内核代码中，我有以下参数：

__kernel void kernelHeat2D(const double diagx, const double diagy,
                                 const double weightx, const double weighty,
                                 const int size_x,
                                 __global double* tab_current,
                                 __global double* tab_new,
                                 __global double* r)

其中tab_new是输出数组，tab_current是输入数组。 tab_current是第6个参数（在clSetKernelArg中编号为5）。

这就是为什么在NDRangeKernel调用之后，我认为我只能使用：

// Set new Argument - Outputs become Inputs
  status = clSetKernelArg(
      kernel,
      5,
      sizeof(cl_mem),
      (void*)&x_mem_obj);

UPDATE2：

UPDATE1 中的上述方法不起作用：我得到数组“r”中执行的随机差值（我的代码中的缓冲区为r_mem_obj）。这个数组允许计算收敛，所以每次执行时都会得到不同的步数。

要工作，我必须明确地放在主循环中：

while (!convergence) {

clEnqueueNDRangeKernel();

// Read output buffer and put it into xOutput
clEnqueueReadBuffer( x_mem_obj, xOutput);

// Read error buffer and put it into r
clEnqueueReadBuffer( r_mem_obj, r);

// Write output array to input buffer
clEnqueueWriteBuffer( x0_mem_obj, xOutput)

// put input buffer into input argument for next call of NDRangeKernel
status = clSetKernelArg(
      kernel,
      5,
      sizeof(cl_mem),
       (void*)&x0_mem_obj);
}

我希望避免使用ReadBuffer和WriteBuffer（强制设置xOutput输入x0_mem_obj缓冲区），因为从时间执行的角度来看，它会提供较差的效果

欢迎任何帮助

Answer 1

问题似乎是您只将输出设置为输入，然后您具有与输入和输出相同的缓冲区。你需要交换缓冲区：

buffer1 = create buffer 1
buffer2 = create buffer 2

clEnqueueWriteBuffer(..., buffer1, ...);
clEnqueueWriteBuffer(..., buffer2, ...);

cl_mem *ptrInput = &buffer1;
cl_mem *ptrOutput = &buffer2;

for(..)
{
    clSetKernelArg(..., inputIdx, ptrInput, ...);
    clSetKernelArg(..., outputIdx, ptrOutout, ...);
    clEnqueueNDRangeKernel(...);

    // swap buffers
    cl_mem *ptrTpm = ptrInput;
    ptrInput = ptrOutput;
    ptrOuput = ptrTmp;
}

// ...
// Read results data back
clEnqueueReadBuffer(..., ptrInput, ...); // read from ptrInput because we did extra swap

OpenCL - clEnqueueNDRangeKernel - 输出数组变为输入数组

1 个答案: