Question

更新II：我写了两个例子来说明在接受的答案和评论中提出的想法。第一个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：我想这个问题可以归纳为：＆＃34;是否有一种现代C ++方法等同于多态类似函数的宏？＆＃34; < /强>

我想知道是否可以用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

1 个答案: