SIMD o no SIMD - multiplataforma

Question

Necesito alguna idea sobre cómo escribir una implementación multiplataforma C++ de algunos problemas paralelizables de forma que pueda aprovechar SIMD (SSE, SPU, etc.) si está disponible. Además, quiero poder en el tiempo de ejecución cambiar entre SIMD y no SIMD.

¿Cómo me sugerirías para abordar este problema? (Por supuesto que no quiero implementar el problema varias veces para todas las opciones posibles)

Veo que esta tarea puede no ser muy fácil con C++, pero creo que me falta algo. Hasta ahora mi idea se parece a esto ... Una clase cStream será una matriz de un solo campo. Usando múltiples cStreams puedo lograr SoA (Estructura de matrices). Luego, usando algunos Funtores puedo falsificar la función Lambda que necesito que se ejecute en todo el 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))); 
} 

Dónde for_each será responsable de incrementar el puntero actual de las corrientes, así como inlining cuerpo de los funtores con SIMD y sin SIMD.

algo así:

// 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>()); 
} 

Tenga en cuenta que si el SIMD está activado se comprueba una vez que el bucle es de alrededor del funtor principal.

Answer 1

Si alguien está interesado este es el código sucia vengo con poner a prueba una nueva idea que llegué con tiempo leyendo sobre la biblioteca que Paul publicó.

Gracias Paul!

// 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; 
} 

Answer 2

Observe que el ejemplo dado decide qué ejecutar en tiempo de compilación (ya que está usando el preprocesador), en este caso puede usar técnicas más complejas para decidir qué desea ejecutar; Por ejemplo, Despacho de etiqueta: http://cplusplus.co.il/2010/01/03/tag-dispatching/ Siguiendo el ejemplo que se muestra allí, puede hacer que la implementación rápida sea con SIMD, y la lenta sin.

Answer 3

Es posible que desee ver en la fuente para la biblioteca MacSTL para algunas ideas en esta área: www.pixelglow.com/macstl/

Answer 4

Es posible que desee echar un vistazo a mi intento de SIMD/no SIMD:

• vrep, una clase base con plantilla con especializaciones para SIMD (tenga en cuenta la forma en que distingue entre los flotadores de sólo SSE y SSE2, que introdujeron vectores enteros).

• Más útil v4f, v4i etc clases (subclasificado mediante intermedio v4).

Por supuesto que es mucho más orientado hacia los vectores de 4 elementos para rgba/xyz cálculos tipo que SOA, por lo que será completamente perdido fuelle cuando 8 vías AVX llega, pero los principios generales podrían ser útiles.

Answer 5

El enfoque más impresionante para SIMD-escala que he visto es el marco RTFact ray-tracing: slides, paper. Vale la pena echarle un vistazo.Los investigadores están estrechamente asociados con Intel (Saarbrucken ahora alberga el Intel Visual Computing Institute) por lo que puede estar seguro de que se ampliará el AVX y Larrabee estaba en sus mentes.

La biblioteca de plantillas de "paralelismo de datos" de Intel Ct parece bastante prometedora.

Answer 6

¿Ha pensado en usar soluciones existentes como liboil? Implementa lots of common SIMD operations y puede decidir en tiempo de ejecución si se usa el código SIMD/no SIMD (usando los punteros de función asignados por una función de inicialización).