编写一个通用内核并将其映射到不同的 ISA

Question

更新二：我写了两个例子来说明接受的答案和评论中提出的想法。第一个 math_cmp.cc 执行显式类型操作。

// math_cmp.cc
#include <iostream>
#include <xmmintrin.h>

using namespace std;

int main()
{
    float a, b;
    cin >> a >> b;

    float res = (a + b) * (a - b);

    cout << res << endl;

    __m128 a_vec, b_vec, res_vec;
    a_vec = _mm_set1_ps(a);
    b_vec = _mm_set1_ps(b);
    res_vec = _mm_mul_ps(_mm_add_ps(a_vec, b_vec),
            _mm_sub_ps(a_vec, b_vec));

    float *res_ptr;
    res_ptr = (float *) &res_vec;
    for (int i = 0; i < 4; ++i)
    cout << "RES[" << i << "]: " << res_ptr[i] << ' ';
    cout << endl;

    return 0;
}

第二个文件math_traits.cc执行模板+特征。使用-O3 编译时生成的程序集几乎与math_cmp.cc 完全相同。

// math_traits.cc
#include <iostream>
#include <xmmintrin.h>

using namespace std;

template <typename T>
class MathOps
{
};

template <typename T>
T kernel (T a, T b)
{
    T res = MathOps<T>::mul(MathOps<T>::add(a, b), MathOps<T>::sub(a, b));

    return res;
}

template <>
class MathOps <float>
{
public:
    static float add (float a, float b)
    {
    return a + b;
    }

    static float sub (float a, float b)
    {
    return a - b;
    }

    static float mul (float a, float b)
    {
    return a * b;
    }
};

template <>
class MathOps <__m128>
{
public:
    static __m128 add (__m128 a, __m128 b)
    {
    return a + b;
    }

    static __m128 sub (__m128 a, __m128 b)
    {
    return a - b;
    }

    static __m128 mul (__m128 a, __m128 b)
    {
    return a * b;
    }
};

int main ()
{
    float a, b;
    cin >> a >> b;
    cout << kernel<float>(a, b) << endl;

    __m128 a_vec, b_vec, res_vec;
    a_vec = _mm_set1_ps(a);
    b_vec = _mm_set1_ps(b);
    res_vec = kernel<__m128>(a_vec, b_vec);

    float *res_ptr;
    res_ptr = (float *) &res_vec;
    for (int i = 0; i < 4; ++i)
    cout << "RES[" << i << "]: " << res_ptr[i] << ' ';
    cout << endl;

    return 0;
}

更新一：我想这个问题可以概括为："Is there a modern C++ approach that is equivalent to polymorphic function-like macros?"

我想知道是否有可能用 C++ 编写一个具有抽象操作的内核，并自动生成 ISA 特定的代码。例如，通用内核可以是：

RET_TYPE kernel(IN_TYPE a, IN_TYPE b)
{
    RET_TYPE res = ADD(a, b);
    return res;
}

并且内核可以转化为两者一个标量版本：

float kernel(float a, float b)
{
    float res = a + b;
    return res;
}

和矢量化版本：

__m128 kernel(__m128 a, __m128 b)
{
    __m128 res = _mm_add_ps(a, b);
    return res;
}

实际上，通用内核会复杂得多。类型中的通用性可以由模板参数处理。但是说明的通用性让我陷入困境。

通常，此类问题是通过 代码生成 解决的，您可以在 中间表示 (IR) 中编写程序，并且然后将 IR 表达式翻译成各种目标语言。

但是，我必须在 纯现代 C++ 中完成，这意味着没有 C 宏。我想知道它是否可以通过巧妙地利用 通用编程 、 模板元编程 或 OOP 来实现。如果您有一些指示，请帮忙！

Answer 1

通常可以通过模板和类型特征实现：

template <typename T>
T kernel(T a, T b)
{
     return MathTraits<T>::add (a, b);
}
template <typename T>
class MathTraits 
{
}
// specialization for float
template <>
class MathTraits <float>
{
     float add(float a, float b)
     {
          return a+b;
     }
}
// specialization of MathTraits for __m128 etc.

但是，当您可能希望在不同情况下以不同方式对待同一类型时，这种方法可能会失败。但这是超载的一般限制...

根据给出的示例，实际上可以直接专门化函数，但描述的方式更常见，因为它更清晰和可重用。

编写一个通用内核并将其映射到不同的 ISA

Write one generic kernel and map it to different ISAs

c++

code-generation

generic-programming

template-meta-programming