我可以根据 C++ 中的运行时条件定义类型别名吗？

Question

我正在开发一个 OpenCL 程序，它使用“cl_khr_byte_addressable_store”扩展名来允许在内核代码中进行字节级写入；为了让我的程序也能在不支持扩展的 GPU 上运行，我需要检查扩展是否可用，并在不支持的平台上使用 int 类型而不是 char。

在内核代码中，我可以简单地添加以下 sn -p 并在整个内核代码中使用writeable_type；如果扩展可用，则 OpenCL 内核编译器会自动添加预处理器定义 cl_khr_byte_addressable_store。

/* kernel.cl */
#ifdef cl_khr_byte_addressable_store
    typedef char writeable_type;
#else
    typedef int writeable_type;
#endif

f() {
    writeable_type x = 1;
}

在我的主机代码中，我没有那个预处理器定义，并且（据我所知）检查扩展是否可用只能在运行时完成：

/* host.cpp */
void execute() {
    std::string extensions;
    this->opencl->getExtensions(extensions);
    if (extensions.find("cl_khr_byte_addressable_store") != std::string::npos) {
        // extension is available
        typedef cl_char writeable_type;
    }
    else {
        // extension is not available
        typedef cl_int writeable_type;
    }
    writeable_type x = 1;
}

这就是我的问题；因为 typedef 是在编译时解析的，并且只在定义它们的块内有效，所以上面的示例不起作用。

是否有可能以某种方式做到这一点？

---

感谢 rlc、Neil Butterworth 和 talonmis 让我走上了正确的道路！结果证明我的问题的解决方案相当简单：

/*host.cpp*/

void execute() {
   bool extension_available = ...;  
   if (extension_available)
       this->_execute<cl_char>();
   else
       this->_execute<cl_int>();
}

template <typename writeable_char>
void _execute() {
    writeable_type x = 1;
    // ...
}

Answer 1

如果你的所有代码都在一个公共函数与类型无关的类中，你可以这样做：

// assuming these are defined in OpenCL somewhere
typedef char cl_char;
typedef int cl_int;

// the public part of the base class cannot use the 
// writable size because it cannot know the size of the writable type
class Base
{
public :
    /* stuff */
    virtual void doStuff() = 0;
    /* more stuff */
};

// the writable type's size is known in this class and is
// either cl_char or cl_int, so this is where data that has
// to know the size will be carried around, and where API calls
// that need to know the exact writable type go.
// Code that is agnostic of the writable type need not be here
// (but can be)
template < typename WritableType >
class Derived : public Base
{
public :
    virtual void doStuff()
    {
        /* do stuff */
    }
};

int main()
{
    bool condition(false);
    /* magic to check for type size here */
    // once you get here, you know what the writable type is going to be,
    // so you can create an instance of the derived class accordingly
    Base *o;
    if (condition)
    {
        o = new Derived< cl_char >;
    }
    else
    {
        o = new Derived< cl_int >;
    }
    // as of here, you no longer need to know what the writable type
    // is because that knowledge is encapsulated in the object o
    o->doStuff();
}

即模板化根据您在运行时需要的类型执行所有操作的类，并使用您需要的版本。

Answer 2

在编译时必须知道 C++ 中的所有类型 - 此规则不可能有任何例外（对于 C 也是如此）。考虑到语言的定义方式，在运行时重新定义类型的尝试根本没有意义。如果你发现你认为你需要这样做，那么你的设计就有问题。

Answer 3

您必须对目标 OpenCL 平台使用的选项进行运行时检查并做出相应的反应。使用CL_PLATFORM_EXTENSIONS 查询调用clGetPlatformInfo，您将返回一个字符数组，可以对其进行解析以检查是否支持cl_khr_byte_addressable_store。然后相应地选择具有整数或字符类型的路径。

大多数供应商 SDK 都包含某种设备查询应用程序，其中包含 clGetPlatformInfo 使用示例。你应该可以从那里抄一些代码。

Answer 4

您试图在编译时根据运行时某物的值来更改变量。除非您将编译时提前到运行时，例如使用 JIT 或解释，或者发明时间旅行，否则物理定律决定了您想要什么是不可能的。

当然，你也可以使用继承和虚函数来移除依赖。