Блог

ОБНОВЛЕНИЕ 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 *) amp;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 *) amp;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. Интересно, достижимо ли это, умело используя универсальное программирование, шаблонное метапрограммирование или ООП. Пожалуйста, помогите, если у вас есть какие-то указания!

Как правило, это достижимо с помощью шаблонов и признаков типа:

 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.
  

Однако этот подход может привести к сбою, если вы захотите по-разному обрабатывать один и тот же тип в разных ситуациях. Но это общий предел перегрузки…

В приведенном примере на самом деле возможно напрямую специализировать функцию, но описанный способ является более распространенным, поскольку он более понятен и используется повторно.