alineación de memoria de gcc pragma

Question

¿Tiene gcc pragma de alineación de memoria, similar a #pragma vector aligned en el compilador de Intel? Me gustaría decirle al compilador que optimice un bucle particular utilizando cargas alineadas/instrucciones de la tienda. para evitar posibles confusiones, no se trata de una estructura de embalaje.

por ejemplo:

#if defined (__INTEL_COMPILER) 
#pragma vector aligned 
#endif 
     for (int a = 0; a < int(N); ++a) { 
      q10 += Ix(a,0,0)*Iy(a,1,1)*Iz(a,0,0); 
      q11 += Ix(a,0,0)*Iy(a,0,1)*Iz(a,1,0); 
      q12 += Ix(a,0,0)*Iy(a,0,0)*Iz(a,0,1); 
      q13 += Ix(a,1,0)*Iy(a,0,0)*Iz(a,0,1); 
      q14 += Ix(a,0,0)*Iy(a,1,0)*Iz(a,0,1); 
      q15 += Ix(a,0,0)*Iy(a,0,0)*Iz(a,1,1); 
     } 

Gracias

Answer 1

De http://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html

typedef double aligned_double __attribute__((aligned (16))); 
// Note: sizeof(aligned_double) is 8, not 16 
void some_function(aligned_double *x, aligned_double *y, int n) 
{ 
    for (int i = 0; i < n; ++i) { 
     // math! 
    } 
} 

esto no hará que aligned_double 16 bytes de ancho. Esto solo lo alineará con un límite de 16 bytes, o más bien será el primero en una matriz. Al mirar el desmontaje en mi computadora, tan pronto como uso la directiva de alineación, empiezo a ver MUCHAS operaciones vectoriales. Estoy usando una computadora de arquitectura Power en este momento, así que es un código de altivec, pero creo que hace lo que quieres.

. (Nota: no estaba usando double cuando probé esto, porque hay AltiVec no admite dobles flotadores)

Se puede ver otros ejemplos de autovectorization utilizando el tipo de atributos aquí: http://gcc.gnu.org/projects/tree-ssa/vectorization.html

Answer 2

Intenté su solución con la versión 4.5.2 de g ++ (tanto Ubuntu como Windows) y no vectorize el ciclo.

Si se elimina el atributo de alineación, vectoriza el ciclo, utilizando cargas desalineadas.

Si la función está en línea para que se pueda acceder directamente a la matriz con el puntero eliminado, se vectoriza con cargas alineadas.

En ambos casos, el atributo de alineación impide la vectorización. Esto es irónico: se suponía que "aligned_double * x" permitía la vectorización, pero hace lo contrario.

¿Qué compilador reportó bucles vectorizados? Sospecho que no era un compilador gcc?

Answer 3

¿Tiene gcc tienen memoria alineación pragma, similar vectorial #pragma alineado

Parece que las nuevas versiones de GCC tiene __builtin_assume_aligned:

función incorporada: void * __builtin_assume_aligned (const void *exp, size_t align, ...)

Esta función devuelve su primer argumento, y permite al compilador suponer que el puntero devuelto está al menos alineando los bytes alineados. Este built-in puede tener dos o tres argumentos, si tiene tres, el tercer argumento debe tener un tipo entero, y si es distinto de cero significa desalineación.Por ejemplo:

void *x = __builtin_assume_aligned (arg, 16); 

significa que el compilador puede asumir x, ajuste a Arg, es al menos de 16 bytes alineados, mientras que:

void *x = __builtin_assume_aligned (arg, 32, 8); 

significa que el compilador puede asumir para x, se establece en arg, that (char *) x - 8 está alineado con 32 bytes.

Basado en algunas otras preguntas y respuestas en Stack Overflow circa 2010, parece que el built-in no estaba disponible en GCC 3 y principios GCC 4. Pero no sé dónde está el punto de corte.