Question

我创建了一个CPU调度程序，它将具有不同编译选项的相同函数编译到不同的目标文件中。为了让我的代码访问不同目标文件中的相同功能，我需要为每个目标文件中的函数指定一个不同的名称。

在C（或C ++）中，我会在函数声明的头文件中执行类似的操作。

typedef float MyFuncType(float a);

MyFuncType  myfunc_SSE2, myfunc_SSE41, myfunc_AVX, myfunc_AVX2, myfunc_AVX512

但现在我想要声明的函数模板。我的真实代码目前看起来更像是

//kernel.h
template <typename TYPE, unsigned N, typename VALUES>
void foo_SSE2(int32_t *buffer, VALUES & v);

template <typename TYPE, unsigned N, typename VALUES>
void foo_SSE41(int32_t *buffer, VALUES & v);
...
template <typename TYPE, unsigned N, typename VALUES>
void foo_AVX512(int32_t *buffer, VALUES & v);

#if   INSTRSET == 2                    // SSE2
#define FUNCNAME foo_SSE2
#elif INSTRSET == 5                    // SSE4.1
#define FUNCNAME foo_SSE41
...
#if   INSTRSET == 9                    // AVX512
#define FUNCNAME foo_AVX512
#endif

这些只是头文件中的声明。函数定义位于单独的源文件中，该文件被编译为每个函数名称的不同目标文件。定义看起来像这样

//kernel.cpp
#include "kernel.h"
template<typename TYPE, unsigned N, typename VALUES>
void FUNCNAME(int32_t *buffer, VALUES & v) {
    //code
}

然后我像这样编译

gcc -c -O3 -msse2 kernel.cpp -o kernel_sse2.o
gcc -c -O3 -msse4.1 kernel.cpp -o kernel_sse41.o
...
gcc -c -O3 -mavx512f kernel.cpp -o kernel_avx512.o
gcc -O3 main.cpp kernel_sse2.o kernel_sse41.o ... kernel_avx512.o

文件main.cpp是另一个源文件，只需要知道函数声明，以便链接器可以将它们链接到其他目标文件中的定义。看起来像这样

void dispatch(void) {
    int iset = instrset_detect();
    if (iset >= 9) {
        fp_float1  = &foo_AVX512<float,1>;  
    }
    else if (iset >= 8) {
        fp_float1  = &foo_AVX2<float,1>;
    }
    ...
    else if (iset >= 2) {
        fp_float1  = &foo_SSE2<float,1>;
    }
}
int main(void) {
    dispatch();
    fp_float1(buffer, values);
}

但是在我的文件“kernel.h”中，为函数名称的每次更改重复此操作都很烦人（并且容易出错）。我想要以下内容（我知道它不起作用）。

template <typename TYPE, unsigned N, typename VALUES>
typedef void foo(int32_t *buffer, VALUES & v);

foo foo_SSE2, foo_SSE41, foo_SSE_AVX, foo_AVX2, foo_AVX512

有没有理想的方法来分隔声明和定义，并允许我简单地重命名相同的模板函数声明？

Answer 1

这似乎是预处理器的应用程序：

#define EMIT_FUNCTION_PROTOTYPE(func_name, func_suffix) \
    template<typename TYPE, unsigned N, typename VALUES> \
    void func_name ## func_suffix (int32_t *buffer, VALUES & v)

#define EMIT_FUNCTION_PROTOTYPES(func_name) \
    EMIT_FUNCTION_PROTOTYPE(func_name, _SSE2); \
    EMIT_FUNCTION_PROTOTYPE(func_name, _SSE41); \
    EMIT_FUNCTION_PROTOTYPE(func_name, _AVX); \
    EMIT_FUNCTION_PROTOTYPE(func_name, _AVX2); \
    EMIT_FUNCTION_PROTOTYPE(func_name, _AVX512)

然后它只是一个单行程序来生成头文件中的所有原型：

EMIT_FUNCTION_PROTOTYPES(foo);
// expands to:
//     template <typename TYPE, unsigned N, typename VALUES>
//     void foo_SSE2(int32_t *buffer, VALUES & v);
//
//     template <typename TYPE, unsigned N, typename VALUES>
//     void foo_SSE41(int32_t *buffer, VALUES & v);
//
//     template <typename TYPE, unsigned N, typename VALUES>
//     void foo_AVX(int32_t *buffer, VALUES & v);
//
//     template <typename TYPE, unsigned N, typename VALUES>
//     void foo_AVX2(int32_t *buffer, VALUES & v);
//
//     template <typename TYPE, unsigned N, typename VALUES>
//     void foo_AVX512(int32_t *buffer, VALUES & v);

我不认为这是一个巨大的好处，但它应该给你你想要的东西。

函数模板的别名

1 个答案: