我的内核函数签名如下:

template< size_t S, typename Field, typename Type1, typename Type2>
void kernel(const Type1 arg1, const Type2 arg2, Field *results) {
// S is known at compile time
// Field might be float or double
// Type1 is an object holding data and also methods
// Type2 is an object holding data and also methods

// The computation start here

}

我知道可以使用 c++ 特性的一个子集来使用 extension 编写内核到 AMD 的 OpenCL 实现，但生成的代码仅限于在 AMD 卡上运行。

2.0 之前版本的 OpenCL 语言标准规范限制程序员使用 C99 编写内核，我相信 2.1 和 2.2 版本还没有广泛用于 Linux 发行版。但是，我找到了here Boost::compute 在某种程度上允许在内核规范中使用 c++ 特性的子集。但是，尚不清楚是否可以使用 Boos::compute 实现上述代码片段中的内核签名。在多大程度上可以实现这样的内核？代码示例将不胜感激。

最佳答案

TL;DR:是也不是。在某种程度上确实可以编写模板化内核，但这些内核的功能远不如 CUDA 内核。

I know that is possible to use a subset of the features of c++ to write the kernel using an extension to the implementations of OpenCL from AMD but the resulting code is restricted to run on AMD cards only.

它不仅限于在 AMD 卡上运行。它被限制只能在 AMD 的 OpenCL 实现上编译。例如，它应该可以在 Intel CPU 上正常运行，只要它是在 AMD 的实现上编译的。

I found here that Boost::compute allows to some extent to use a subset of c++ features in the specification of the kernels. However is not clear if it is possible to implement a kernel signature as in the code snippet above using Boos::compute.

Boost.Compute 本质上是 OpenCL C API 之上的奇特抽象层，使其更易于使用且使用起来不那么乏味，但它仍然使您可以完全访问底层 C API。这意味着如果某些东西在 C API 中是可行的，那么理论上它在 Boost.Compute 中也应该是可行的。

由于 OpenCL 代码是在运行时编译的，因此在单独的 channel 中，您将无法像 CUDA 在编译时那样自动进行模板实例化。 CUDA 编译器同时查看主机和设备代码，并且可以在整个调用图中执行适当的模板实例化，就好像它是一个翻译单元一样。按照设计，这在 OpenCL 中是不可能的。

<强>1。您将必须手动实例化您需要的所有可能的模板实例化，破坏它们的名称，然后分派(dispatch)到正确的实例化。

<强>2。模板实例化中使用的所有类型也必须在 OpenCL 代码中定义。

此限制使 OpenCL 模板化内核并非完全无用，但与 CUDA 内核相比也不是很实用。它们的主要目的是避免代码重复。

这种设计的另一个结果是内核模板模板参数列表中不允许非类型模板参数(至少据我所知，但我真的希望在这个!)。这意味着您必须将内核模板的非类型模板参数降低为参数 之一的非类型模板参数。换句话说，转换看起来像这样的东西:

template<std::size_t Size, typename Thing>
void kernel(Thing t);

像这样:

template<typename Size, typename Thing>
void kernel(Size* s, Thing t);

然后通过使用类似于 std::integral_constant<std::size_t, 512> 的精神来区分不同的实例化(或任何其他可以在整数常量上模板化的类型)作为第一个参数。这里的指针只是一个技巧，可以避免需要主机端定义大小类型(因为我们不关心它)。

Disclaimer: my system doesn't support OpenCL, so I could not test the below code. It probably requires some tweaking to work as expected. It does compile, however.

auto source = R"_cl_source_(
    // Type that holds a compile-time size.
    template<std::size_t Size>
    struct size_constant {
        static const std::size_t value = Size;
    };

    // Those should probably be defined somewhere else since
    // the host needs to know about them too.
    struct Thing1 {};
    struct Thing2 {};

    // Primary template, this is where you write your general code.
    template<typename Size, typename Field, typename Type1, typename Type2>
    kernel void generic_kernel(Size*, const Type1 arg1, const Type2 arg2, Field *results) {
        // S is known at compile time
        // Field might be float or double
        // Type1 is an object holding data and also methods
        // Type2 is an object holding data and also methods

        // The computation start here
        // for (std::size_t s = 0; s < Size::value; ++s)
        // ...
    }

    // Instantiate the template as many times as needed.
    // As you can see, this can very quickly become explosive in number of combinations.
    template __attribute__((mangled_name(kernel_512_float_thing1_thing2)))
    kernel void generic_kernel(size_constant<512>*, const Thing1, const Thing2, float*);

    template __attribute__((mangled_name(kernel_1024_float_thing1_thing2)))
    kernel void generic_kernel(size_constant<1024>*, const Thing1, const Thing2, float*);

    template __attribute__((mangled_name(kernel_1024_double_thing1_thing2)))
    kernel void generic_kernel(size_constant<1024>*, const Thing1, const Thing2, double*);
)_cl_source_";

namespace compute = boost::compute;

auto device = compute::system::default_device();
auto context = compute::context { device };
auto queue = compute::command_queue { context, device };

// Build the program.
auto program = compute::program::build_with_source(source, context, "-x clc++");

// Retrieve the kernel entry points.
auto kernel_512_float_thing1_thing2 = program.create_kernel("kernel_512_float_thing1_thing2");
auto kernel_1024_float_thing1_thing2 = program.create_kernel("kernel_1024_float_thing1_thing2");
auto kernel_1024_double_thing1_thing2 = program.create_kernel("kernel_1024_double_thing1_thing2");

// Now you can call these kernels like any other kernel.
// Remember: the first argument is just a dummy.
kernel_512_float_thing1_thing2.set_arg(0, sizeof(std::nullptr_t), nullptr);

// TODO: Set other arguments (not done in this example)

// Finally submit the kernel to the command queue.
auto global_work_size = 512;
auto local_work_size = 64;
queue.enqueue_1d_range_kernel(kernel_512_float_thing1_thing2, 0, global_work_size, local_work_size);

祝您好运，随时用您的更改编辑这篇文章，以便其他人可以从中受益!

关于c++ - OpenCL:是否可以使用模板化对象作为 Boost::compute 的内核参数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48698742/