SIMD или нет SIMD - кросс-платформенный - PullRequest
Новая
       16

SIMD или нет SIMD - кросс-платформенный

12 голосов
/ 23 января 2010

Мне нужна идея, как написать кроссплатформенную реализацию C ++ для нескольких распараллеливаемых задач таким образом, чтобы я мог использовать SIMD (SSE, SPU и т. Д.), Если он доступен. Как и я хочу иметь возможность во время выполнения переключаться между SIMD и не SIMD.

Как вы предлагаете мне подойти к этой проблеме? (Конечно, я не хочу реализовывать проблему несколько раз для всех возможных вариантов)

Я вижу, как это может быть нелегко с C ++, но я считаю, что что-то упустил. Пока моя идея выглядит так ... Класс cStream будет массивом одного поля. Используя несколько cStreams, я могу достичь SoA (структура массивов). Затем, используя несколько функторов, я могу подделать лямбда-функцию, которую нужно выполнить для всего cStream. 

// just for example I'm not expecting this code to compile
cStream a; // something like float[1024]
cStream b;
cStream c;

void Foo()
{
    for_each(
        AssignSIMD(c, MulSIMD(AddSIMD(a, b), a)));
}

Где for_each будет отвечать за увеличение текущего указателя потоков, а также за включение тела функторов с SIMD и без SIMD.

примерно так: 

// just for example I'm not expecting this code to compile
for_each(functor<T> f)
{
#ifdef USE_SIMD
    if (simdEnabled)
        real_for_each(f<true>()); // true means use SIMD
    else
#endif
        real_for_each(f<false>());
}

Обратите внимание, что если SIMD включен, проверяется один раз, и петля проходит вокруг главного функтора.

Ответы [ 6 ]

3 голосов
/ 23 января 2010

Если кому-то интересно, это грязный код, с которым я пришел, чтобы проверить новую идею, с которой я пришел, читая о библиотеке, которую выложил Пол.

Спасибо, Пол! 

// This is just a conceptual test
// I haven't profile the code and I haven't verified if the result is correct
#include <xmmintrin.h>


// This class is doing all the math
template <bool SIMD>
class cStreamF32
{
private:
    void*       m_data;
    void*       m_dataEnd;
    __m128*     m_current128;
    float*      m_current32;

public:
    cStreamF32(int size)
    {
        if (SIMD)
            m_data = _mm_malloc(sizeof(float) * size, 16);
        else
            m_data = new float[size];
    }
    ~cStreamF32()
    {
        if (SIMD)
            _mm_free(m_data);
        else
            delete[] (float*)m_data;
    }

    inline void Begin()
    {
        if (SIMD)
            m_current128 = (__m128*)m_data;
        else
            m_current32 = (float*)m_data;
    }

    inline bool Next()
    {
        if (SIMD)
        {
            m_current128++;
            return m_current128 < m_dataEnd;
        }
        else
        {
            m_current32++;
            return m_current32 < m_dataEnd;
        }
    }

    inline void operator=(const __m128 x)
    {
        *m_current128 = x;
    }
    inline void operator=(const float x)
    {
        *m_current32 = x;
    }

    inline __m128 operator+(const cStreamF32<true>& x)
    {
        return _mm_add_ss(*m_current128, *x.m_current128);
    }
    inline float operator+(const cStreamF32<false>& x)
    {
        return *m_current32 + *x.m_current32;
    }

    inline __m128 operator+(const __m128 x)
    {
        return _mm_add_ss(*m_current128, x);
    }
    inline float operator+(const float x)
    {
        return *m_current32 + x;
    }

    inline __m128 operator*(const cStreamF32<true>& x)
    {
        return _mm_mul_ss(*m_current128, *x.m_current128);
    }
    inline float operator*(const cStreamF32<false>& x)
    {
        return *m_current32 * *x.m_current32;
    }

    inline __m128 operator*(const __m128 x)
    {
        return _mm_mul_ss(*m_current128, x);
    }
    inline float operator*(const float x)
    {
        return *m_current32 * x;
    }
};

// Executes both functors
template<class T1, class T2>
void Execute(T1& functor1, T2& functor2)
{
    functor1.Begin();
    do
    {
        functor1.Exec();
    }
    while (functor1.Next());

    functor2.Begin();
    do
    {
        functor2.Exec();
    }
    while (functor2.Next());
}

// This is the implementation of the problem
template <bool SIMD>
class cTestFunctor
{
private:
    cStreamF32<SIMD> a;
    cStreamF32<SIMD> b;
    cStreamF32<SIMD> c;

public:
    cTestFunctor() : a(1024), b(1024), c(1024) { }

    inline void Exec()
    {
        c = a + b * a;
    }

    inline void Begin()
    {
        a.Begin();
        b.Begin();
        c.Begin();
    }

    inline bool Next()
    {
        a.Next();
        b.Next();
        return c.Next();
    }
};


int main (int argc, char * const argv[]) 
{
    cTestFunctor<true> functor1;
    cTestFunctor<false> functor2;

    Execute(functor1, functor2);

    return 0;
}
3 голосов
/ 23 января 2010

Возможно, вы захотите взглянуть на источник для библиотеки MacSTL для некоторых идей в этой области: www.pixelglow.com / macstl /

2 голосов
/ 23 января 2010

Самым впечатляющим подходом к SIMD-масштабированию, который я видел, является структура трассировки лучей RTFact: слайды , бумага . Стоит посмотреть. Исследователи тесно связаны с Intel (в Саарбрюккене сейчас находится Институт визуальных вычислений Intel), поэтому вы можете быть уверены, что масштабируете вперед AVX, и Larrabee задумался.

Библиотека шаблонов Intel " Ct " параллелизм данных "также выглядит довольно многообещающе.

2 голосов
/ 23 января 2010

Возможно, вы захотите взглянуть на мою попытку SIMD / не SIMD:

  • vrep , шаблонный базовый класс со специализациями для SIMD (примечаниекак он различает плавающие SSE и SSE2, в которых введены целочисленные векторы.).

  • Более полезные v4f , v4i и др(подклассы через промежуточный v4 ).

Конечно, он гораздо больше ориентирован на векторы из 4 элементов для rgba / xyz типа вычислений, чем SoA, поэтому, когда выйдет 8-way AVX, он полностью выдохнется, но общие принципы могут быть полезны.

1 голос
/ 23 января 2010

Обратите внимание, что данный пример решает, что выполнять во время компиляции (поскольку вы используете препроцессор), в этом случае вы можете использовать более сложные приемы, чтобы решить, что вы действительно хотите выполнить; Например, Диспетчер тегов: http://cplusplus.co.il/2010/01/03/tag-dispatching/ Следуя приведенному там примеру, вы можете иметь быструю реализацию с SIMD, а медленную - без.

0 голосов
/ 23 января 2010

Задумывались ли вы об использовании существующих решений, таких как liboil ? Он реализует много общих операций SIMD и может решить во время выполнения, использовать ли код SIMD / не SIMD (используя указатели функций, назначенные функцией инициализации).

...