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

更新二:我写了两个例子来说明在接受的回答和评论中提出的想法。第一个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执行模板+ traits。用-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;
}

---

更新1:我想这个问题可以概括为:"是否有一种现代c++方法等价于多态类函数宏?"

---

我想知道是否有可能用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来实现。请帮助，如果你有一些建议!

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.