Question

我正在使用jogamp jocl库在Java中学习openCL。我的一个测试是停止Mandelbrot地图。我有四个测试：简单串行，使用Java执行器接口并行，单个设备使用openCL，多个设备使用openCL。前三个是好的，最后一个没有。当我将多个设备的（正确）输出与多设备解决方案的错误输出进行比较时，我注意到颜色大致相同，但最后一个的输出是乱码。我想我明白问题所在，但我无法解决。

问题是（imho）openCL使用向量缓冲区，我必须将输出转换为矩阵。我认为这个翻译是不正确的。我通过将mandelbrot地图划分为矩形来平行化代码，其中宽度（xSize）除以任务数量并保留高度（ySize）。我认为我能够将该信息正确地传输到内核中，但将其翻译回来是不正确的。

  CLMultiContext mc = CLMultiContext.create (deviceList);
  try 
  {
     CLSimpleContextFactory factory = CLQueueContextFactory.createSimple (programSource);
     CLCommandQueuePool<CLSimpleQueueContext> pool = CLCommandQueuePool.create (factory, mc);
     IntBuffer dataC = Buffers.newDirectIntBuffer (xSize * ySize);
     IntBuffer subBufferC = null;
     int tasksPerQueue = 16;
     int taskCount = pool.getSize () * tasksPerQueue;
     int sliceWidth = xSize / taskCount;
     int sliceSize = sliceWidth * ySize;
     int bufferSize = sliceSize * taskCount;
     double sliceX = (pXMax - pXMin) / (double) taskCount;
     String kernelName = "Mandelbrot";

     out.println ("sliceSize: " + sliceSize);
     out.println ("sliceWidth: " + sliceWidth);
     out.println ("sS*h:" + sliceWidth * ySize);
     List<CLTestTask> tasks = new ArrayList<CLTestTask> (taskCount);

     for (int i = 0; i < taskCount; i++) 
     {
        subBufferC = Buffers.slice (dataC, i * sliceSize, sliceSize);
        tasks.add (new CLTestTask (kernelName, i, sliceWidth, xSize, ySize, maxIterations, 
              pXMin + i * sliceX, pYMin, xStep, yStep, subBufferC));
     } // for

     pool.invokeAll (tasks);

     // submit blocking immediately
     for (CLTestTask task: tasks) pool.submit (task).get ();

     // Ready read the buffer into the frequencies matrix
     // according to me this is the part that goes wrong
     int w = taskCount * sliceWidth;
     for (int tc = 0; tc < taskCount; tc++)
     {
        int offset = tc * sliceWidth;

        for (int y = 0; y < ySize; y++)
        {
           for (int x = offset; x < offset + sliceWidth; x++)
           {
              frequencies [y][x] = dataC.get (y * w + x);
           } // for
        } // for
     } // for

     pool.release();

最后一个循环是罪魁祸首，这意味着（我认为）内核编码和主机转换之间存在不匹配。内核：

kernel void Mandelbrot 
(
   const int width,        
   const int height,
   const int maxIterations,
   const double x0,      
   const double y0,
   const double stepX,  
   const double stepY,
   global int *output   
) 
{
    unsigned ix = get_global_id (0);
    unsigned iy = get_global_id (1);

    if (ix >= width) return;
    if (iy >= height) return;

    double r = x0 + ix * stepX;
    double i = y0 + iy * stepY;

    double x = 0;
    double y = 0;

    double magnitudeSquared = 0;
    int iteration = 0;

    while (magnitudeSquared < 4 && iteration < maxIterations) 
    {
        double x2 = x*x;
        double y2 = y*y;
        y = 2 * x * y + i;
        x = x2 - y2 + r;
        magnitudeSquared = x2+y2;
        iteration++;
    }

    output [iy * width + ix] = iteration;
}

最后一个语句将信息编码到向量中。该内核也由单个设备版本使用。唯一的区别是在多设备版本中我改变了宽度和x0。正如您在Java代码中看到的那样，我将xSize / number_of_tasks作为宽度传输，将pXMin + i * sliceX作为x0传输（而不是pXMin）。

我现在正在工作几天，已经删除了一些错误，但我现在无法再看到我做错了什么。非常感谢帮助。

修改1

@Huseyin要求提供图片。第一个截图由openCL单个设备计算。

第二个屏幕截图是多设备版本，使用完全相同的参数计算。

修改2

有一个关于如何将缓冲区排入队列的问题。正如你在上面的代码中看到的那样，我有一个list<CLTestTask>，我在其中添加了任务，缓冲区也在其中排队。 CLTestTask是一个内部类，您可以在其中找到下面的代码。

final class CLTestTask实现了CLTask { CLBuffer clBufferC = null; 缓冲区缓冲区; String kernelName; int index; int sliceWidth; int宽度; int height; int maxIterations; 双pXMin; 双pYMin; double x_step; 双y_step;

  public CLTestTask 
  (
        String kernelName, 
        int index,
        int sliceWidth,
        int width, 
        int height,
        int maxIterations,
        double pXMin,
        double pYMin,
        double x_step,
        double y_step,
        Buffer bufferSliceC
  )
  {
     this.index = index;
     this.sliceWidth = sliceWidth;
     this.width = width;
     this.height = height;
     this.maxIterations = maxIterations;
     this.pXMin = pXMin;
     this.pYMin = pYMin;
     this.x_step = x_step;
     this.y_step = y_step;
     this.kernelName = kernelName;
     this.bufferSliceC = bufferSliceC;
  } /*** CLTestTask ***/

  public Buffer execute (final CLSimpleQueueContext qc) 
  {
     final CLCommandQueue queue = qc.getQueue ();
     final CLContext context = qc.getCLContext ();
     final CLKernel kernel = qc.getKernel (kernelName);
     clBufferC = context.createBuffer (bufferSliceC);

     out.println (pXMin + " " + sliceWidth);
     kernel
     .putArg (sliceWidth)
     .putArg (height)
     .putArg (maxIterations)
     .putArg (pXMin) // + index * x_step)
     .putArg (pYMin)
     .putArg (x_step)
     .putArg (y_step)
     .putArg (clBufferC)
     .rewind ();

     queue
     .put2DRangeKernel (kernel, 0, 0, sliceWidth, height, 0, 0)
     .putReadBuffer (clBufferC, true);

     return clBufferC.getBuffer ();
  } /*** execute ***/
} /*** Inner Class: CLTestTask ***/

Answer 1

您正在使用

创建子缓冲区

subBufferC = Buffers.slice (dataC, i * sliceSize, sliceSize);

他们的内存数据为：

0 1 3  10 11 12  19 20 21  28 29 30
4 5 6  13 14 15  22 23 24  31 32 33
7 8 9  16 17 18  25 26 27  34 35 36

使用opencl的矩形复制命令？如果是这样，那么你用

访问它们越界

output [iy * width + ix] = iteration;

因为width大于sliceWidth并写入内核中的边界。

如果你没有做矩形副本或子缓冲区，只是从原始缓冲区中获取偏移量，那么它有一个像

这样的内存布局

 0  1  3  4  5  6  7  8  9 | 10 11 12
 13 14 15 16 17 18|19 20 21  22 23 24
 25 26 27|28 29 30 31 32 33  34 35 36

因此，数组被访问/解释为偏斜或计算错误。

您将偏移量作为内核参数。但你也可以从内核入队参数中做到这一点。所以我和j将从它们的真值（而不是零）开始，你不需要在内核中为所有线程添加x0或y0。

我以前写了一个多设备api。它使用多个缓冲区，每个设备一个，它们的大小都与主缓冲区相同。并且他们只是将必要的部分（它们自己的区域）复制到主缓冲区（主机缓冲区），因此内核计算与所有设备完全相同，使用适当的全局范围偏移。不好的一面是，主缓冲区在所有设备上实际上都是重复的。如果您有4 gpus和1GB数据，则总共需要4GB缓冲区。但是这样，无论使用多少设备，内核成分都更容易阅读。

如果每个设备只分配1 / N大小的缓冲区（N个设备中），则需要从子缓冲区的第0个地址复制到主缓冲区的i*sliceHeight，其中i是设备索引，考虑到数组是平的因此需要为每个设备提供opencl api的矩形缓冲区复制命令。我怀疑你也在使用平面数组，并在内核中使用矩形副本和溢出越界。然后我建议：

从内核中删除任何与设备相关的偏移量和参数
将必要的偏移量添加到内核入队参数中，而不是参数
每个设备上的主要缓冲区重复，如果您还没有完成
仅复制与设备相关的必要部分（如果是平面阵列分割则连续，用于2D解释/阵列分割的矩形副本）

如果整个数据不适合设备，您可以尝试映射/取消映射，这样它就不会在后台分配太多。在其页面中说：

多个命令队列可以映射a的区域或重叠区域用于读取的存储器对象（即map_flags = CL_MAP_READ）。内容也可以读取映射用于读取的存储器对象的区域通过在设备上执行的内核。写作的行为在设备上执行的内核到内存对象的映射区域未定义。映射（和取消映射）缓冲区的重叠区域用于写入的图像存储器对象未定义。

并且它没有说，＆＃34;用于读/写的非重叠映射未定义＆＃34;所以你应该可以在每个设备上进行映射，以便在目标缓冲区上进行并发读/写。但是当与USE_HOST_PTR标志一起使用时（为了最大流性能），每个子缓冲区可能需要有一个对齐的指针来开始，这可能会使区域更难分割成适当的块。我为所有设备使用相同的整个数据阵列，因此分割工作不是问题，因为我可以在对齐的缓冲区内映射unmap任何地址。

这是带有1-D分区的2设备结果（上部由cpu，下部由gpu）：

这是在内核中：

    unsigned ix = get_global_id (0)%w2;
     unsigned iy = get_global_id (0)/w2;

        if (ix >= w2) return;
        if (iy >= h2) return;

        double r = ix * 0.001;
        double i = iy * 0.001;

        double x = 0;
        double y = 0;

        double magnitudeSquared = 0;
        int iteration = 0;

        while (magnitudeSquared < 4 && iteration < 255) 
        {
            double x2 = x*x;
            double y2 = y*y;
            y = 2 * x * y + i;
            x = x2 - y2 + r;
            magnitudeSquared = x2+y2;
            iteration++;
        }

        b[(iy * w2 + ix)]   =(uchar4)(iteration/5.0,iteration/5.0,iteration/5.0,244);

采用FX8150（7核，3.7GHz）+ R7_240（700 MHz），512x512尺寸图像（每通道8位+ alpha）

同样使子缓冲区大小与主机缓冲区相同，使得使用动态范围而不是静态（在异构设置，动态turbo频率和打嗝/节流阀的情况下）更快（无重新分配），以帮助动态负载平衡。结合相同参数＆＃34;的功率，它不会导致性能损失。例如，c[i]=a[i]+b[i]需要c[i+i0]=a[i+i0]+b[i+i0]才能在多个设备上工作，如果所有内核都从零开始并且会增加更多周期（除了内存瓶颈和可读性以及分配c = a + b的奇怪之处）。 / p>

OpenCL如何在使用多个设备时重建缓冲区？

1 个答案: