c++ - 编写一个通用内核并将其映射到不同的 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;
}

---

更新 I:我想这个问题可以概括为:“是否有一种现代 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 来实现。如果您有一些指示，请帮忙!

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.

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

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