Question

我正在SYCL中进行矩阵乘法，并且有一个工作代码，其中我将仅并行范围用于，而不是将 nd_range并行用于。现在我想在其中使用障碍，并且据我所知，障碍只能与nd_range一起使用，对吗？我附上我的代码的一部分，请告诉我是否可以在没有nd_range的情况下完成操作，或者应该使用nd_range进行哪些更改。谢谢

queue.submit([&](cl::sycl::handler &cgh) {
    auto A = A_sycl.get_access<cl::sycl::access::mode::read>(cgh);
    auto B = B_sycl.get_access<cl::sycl::access::mode::read>(cgh);
    auto C = C_sycl.get_access<cl::sycl::access::mode::write>(cgh);

    cgh.parallel_for<class test>(
        cl::sycl::range<2>(4, 4), [=](cl::sycl::id<2> id) {
        c_access[id] = A[id] * Y[id.get(1)];
    });

});

Answer 1

使用 nd_range 可以明确指定本地范围。为了能够在内核中放置工作组屏障，您还需要使用 nd_item 而不是 id 来访问更多id位置和大小，例如如全局和本地ID，组范围和本地范围，以及屏障同步原语。

然后，在完成对设备本地内存的读/写（使用仅设备本地访问器）后，可以放置屏障。

使用 range 和 id 无法获得任何功能。它仅用于简化命令组设置和全局内存内核的编写，您希望运行时为您确定工作组的大小，并具有一种简单的方法来索引您的工作项，这与传统的OpenCL方法不同。无论内核多么简单或复杂，都必须始终明确定义NDRange（在SYCL中为nd_range）。

这是一个简单的示例，假设您要启动2D内核。

myQueue.submit([&](cl::sycl::handler& cgh) {
    auto A_ptr = A_buf.get_access<cl::sycl::access::mode::read>(cgh);
    auto B_ptr = B_buf.get_access<cl::sycl::access::mode::read_write>(cgh);
    auto C_ptr = C_buf.get_access<cl::sycl::access::mode::write>(cgh);
    // scratch/local memory for faster memory access to compute the results
    cl::sycl::accessor<int, 1, cl::sycl::access::mode::read_write,
                       cl::sycl::access::target::local>
        C_scratch(range<1>{size}, cgh);

    cgh.parallel_for<example_kernel>(
        cl::sycl::nd_range<2>(range<2>{size >> 3, size >> 3},   // 8, 8
                              range<2>{size >> 4, size >> 4}),  // 4, 4
        [=](cl::sycl::nd_item<2> item) {
          // get the 2D x and y indices
          const auto id_x = item.get_global_id(0);
          const auto id_y = item.get_global_id(1);
          // map the 2D x and y indices to a single linear,
          // 1D (kernel space) index
          const auto width =
              item.get_group_range(0) * item.get_local_range(0);
          // map the 2D x and y indices to a single linear,
          // 1D (work-group) index
          const auto index = id_x * width + id_y;
          // compute A_ptr * B_ptr into C_scratch
          C_scratch[index] = A_ptr[index] * B_ptr[index];
          // wait for result to be written (sync local memory read_write)
          item.barrier(cl::sycl::access::fence_space::local_space);
          // output result computed in local memory
          C_ptr[index] = C_scratch[index];
        });
  });

我正在使用主机数据和SYCL缓冲区的一维表示形式，它解释了从2D索引到单个线性1D索引的映射。

我希望这种解释有助于将这些概念应用到您的案例中。

在SYCL中使用屏障

1 个答案: