Introducción con x86 de Intel SSE instrucciones SIMD
https://stackoverflow.com/questions/1389712
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Quiero aprender más sobre el uso de la ESS.
¿Qué formas hay para aprender, además de la obvia la lectura de la Intel® 64 e IA-32 Arquitecturas de Manuales para Desarrolladores de Software?
Principalmente estoy interesado en trabajar con el GCC X86 Funciones Integradas.
Solución
En primer lugar, yo no lo recomiendo en el uso de la incorporada en funciones - que no son portátiles (a través de los compiladores del mismo arco).
intrínsecos , GCC hace un trabajo maravilloso optimización de las características intrínsecas de la ESS en código optimizado aún más. Siempre se puede echar un vistazo en el montaje y ver cómo utilizar SSE a su pleno potencial.
intrínsecas son fáciles - al igual que las llamadas a funciones normales:
#include <immintrin.h> // portable to all x86 compilers
int main()
{
__m128 vector1 = _mm_set_ps(4.0, 3.0, 2.0, 1.0); // high element first, opposite of C array order. Use _mm_setr_ps if you want "little endian" element order in the source.
__m128 vector2 = _mm_set_ps(7.0, 8.0, 9.0, 0.0);
__m128 sum = _mm_add_ps(vector1, vector2); // result = vector1 + vector 2
vector1 = _mm_shuffle_ps(vector1, vector1, _MM_SHUFFLE(0,1,2,3));
// vector1 is now (1, 2, 3, 4) (above shuffle reversed it)
return 0;
}
Uso _mm_load_ps o _mm_loadu_ps a datos de carga de las matrices.
Por supuesto que hay manera más opciones, SSE es realmente de gran alcance y en mi opinión relativamente fácil de aprender.
https://stackoverflow.com/tags/sse/info para algunos enlaces a guías.
Otros consejos
Has solicitado que los recursos:
Una guía práctica para el uso SSE con C ++ : Buena visión general conceptual sobre cómo utilizar eficazmente SSE , con ejemplos.
MSDN Listado de Compilador intrínseco : Integral referencia para todas sus necesidades intrínsecas. Es MSDN, pero casi todos los intrínsecos mencionados aquí son soportados por GCC e ICC también.
deChristopher Wright SSE Página : Referencia rápida sobre los significados de la ESS códigos de operación. Supongo que los manuales de Intel se puede servir a la misma función, pero esto es más rápido.
Es probablemente el mejor para escribir la mayor parte de su código en los intrínsecos, pero comprobar el objdump de la salida de su compilador para asegurarse de que se está produciendo un código eficiente. SIMD generación de código es todavía una tecnología relativamente nueva y es muy posible que el compilador podría equivocarse en algunos casos.
Me parece guías de investigación y optimización del Dr. Agner Fog muy valioso! Él también tiene algunas bibliotecas y herramientas de prueba que no he probado hasta ahora. http://www.agner.org/optimize/
Paso 1:escribir algunos asamblea manualmente
Te recomiendo que primero intente escribir su propia asamblea manualmente para ver y controlar exactamente lo que está sucediendo cuando usted comienza a aprender.
Entonces la pregunta es: ¿cómo observar lo que está sucediendo en el programa, y las respuestas son:
- GDB
- el uso de la biblioteca estándar de C a
printyassertcosas
El uso de la biblioteca estándar de C ti requiere un poco de trabajo, pero no mucho.Por ejemplo, he hecho este trabajo muy bien en Linux en los siguientes archivos de mi configuración de prueba:
El uso de los asistentes, luego de empezar a jugar con los conceptos básicos, tales como:
- cargar y almacenar los datos a / desde la memoria en la ESS registros
- agregar los números enteros y de punto flotante los números de diferentes tamaños
- afirmar que los resultados son lo que espero
addpd.S
#include <lkmc.h>
LKMC_PROLOGUE
.data
.align 16
addps_input0: .float 1.5, 2.5, 3.5, 4.5
addps_input1: .float 5.5, 6.5, 7.5, 8.5
addps_expect: .float 7.0, 9.0, 11.0, 13.0
addpd_input0: .double 1.5, 2.5
addpd_input1: .double 5.5, 6.5
addpd_expect: .double 7.0, 9.0
.bss
.align 16
output: .skip 16
.text
/* 4x 32-bit */
movaps addps_input0, %xmm0
movaps addps_input1, %xmm1
addps %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, addps_expect, $0x10)
/* 2x 64-bit */
movaps addpd_input0, %xmm0
movaps addpd_input1, %xmm1
addpd %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, addpd_expect, $0x10)
LKMC_EPILOGUE
paddq.S
#include <lkmc.h>
LKMC_PROLOGUE
.data
.align 16
input0: .long 0xF1F1F1F1, 0xF2F2F2F2, 0xF3F3F3F3, 0xF4F4F4F4
input1: .long 0x12121212, 0x13131313, 0x14141414, 0x15151515
paddb_expect: .long 0x03030303, 0x05050505, 0x07070707, 0x09090909
paddw_expect: .long 0x04030403, 0x06050605, 0x08070807, 0x0A090A09
paddd_expect: .long 0x04040403, 0x06060605, 0x08080807, 0x0A0A0A09
paddq_expect: .long 0x04040403, 0x06060606, 0x08080807, 0x0A0A0A0A
.bss
.align 16
output: .skip 16
.text
movaps input1, %xmm1
/* 16x 8bit */
movaps input0, %xmm0
paddb %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, paddb_expect, $0x10)
/* 8x 16-bit */
movaps input0, %xmm0
paddw %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, paddw_expect, $0x10)
/* 4x 32-bit */
movaps input0, %xmm0
paddd %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, paddd_expect, $0x10)
/* 2x 64-bit */
movaps input0, %xmm0
paddq %xmm1, %xmm0
movaps %xmm0, output
LKMC_ASSERT_MEMCMP(output, paddq_expect, $0x10)
LKMC_EPILOGUE
Paso 2:escribir algunas de las características intrínsecas
Para el código de producción, sin embargo, es probable que se desea usar el pre-existentes de las características intrínsecas en lugar de raw de la asamblea, como se menciona en: https://stackoverflow.com/a/1390802/895245
Así que ahora trato de convertir los ejemplos anteriores en más o menos equivalente en código C con las características intrínsecas.
addpq.c
#include <assert.h>
#include <string.h>
#include <x86intrin.h>
float global_input0[] __attribute__((aligned(16))) = {1.5f, 2.5f, 3.5f, 4.5f};
float global_input1[] __attribute__((aligned(16))) = {5.5f, 6.5f, 7.5f, 8.5f};
float global_output[4] __attribute__((aligned(16)));
float global_expected[] __attribute__((aligned(16))) = {7.0f, 9.0f, 11.0f, 13.0f};
int main(void) {
/* 32-bit add (addps). */
{
__m128 input0 = _mm_set_ps(1.5f, 2.5f, 3.5f, 4.5f);
__m128 input1 = _mm_set_ps(5.5f, 6.5f, 7.5f, 8.5f);
__m128 output = _mm_add_ps(input0, input1);
/* _mm_extract_ps returns int instead of float:
* * https://stackoverflow.com/questions/5526658/intel-sse-why-does-mm-extract-ps-return-int-instead-of-float
* * https://stackoverflow.com/questions/3130169/how-to-convert-a-hex-float-to-a-float-in-c-c-using-mm-extract-ps-sse-gcc-inst
* so we must use instead: _MM_EXTRACT_FLOAT
*/
float f;
_MM_EXTRACT_FLOAT(f, output, 3);
assert(f == 7.0f);
_MM_EXTRACT_FLOAT(f, output, 2);
assert(f == 9.0f);
_MM_EXTRACT_FLOAT(f, output, 1);
assert(f == 11.0f);
_MM_EXTRACT_FLOAT(f, output, 0);
assert(f == 13.0f);
/* And we also have _mm_cvtss_f32 + _mm_shuffle_ps, */
assert(_mm_cvtss_f32(output) == 13.0f);
assert(_mm_cvtss_f32(_mm_shuffle_ps(output, output, 1)) == 11.0f);
assert(_mm_cvtss_f32(_mm_shuffle_ps(output, output, 2)) == 9.0f);
assert(_mm_cvtss_f32(_mm_shuffle_ps(output, output, 3)) == 7.0f);
}
/* Now from memory. */
{
__m128 *input0 = (__m128 *)global_input0;
__m128 *input1 = (__m128 *)global_input1;
_mm_store_ps(global_output, _mm_add_ps(*input0, *input1));
assert(!memcmp(global_output, global_expected, sizeof(global_output)));
}
/* 64-bit add (addpd). */
{
__m128d input0 = _mm_set_pd(1.5, 2.5);
__m128d input1 = _mm_set_pd(5.5, 6.5);
__m128d output = _mm_add_pd(input0, input1);
/* OK, and this is how we get the doubles out:
* with _mm_cvtsd_f64 + _mm_unpackhi_pd
* https://stackoverflow.com/questions/19359372/mm-cvtsd-f64-analogon-for-higher-order-floating-point
*/
assert(_mm_cvtsd_f64(output) == 9.0);
assert(_mm_cvtsd_f64(_mm_unpackhi_pd(output, output)) == 7.0);
}
return 0;
}
paddq.c
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include <x86intrin.h>
uint32_t global_input0[] __attribute__((aligned(16))) = {1, 2, 3, 4};
uint32_t global_input1[] __attribute__((aligned(16))) = {5, 6, 7, 8};
uint32_t global_output[4] __attribute__((aligned(16)));
uint32_t global_expected[] __attribute__((aligned(16))) = {6, 8, 10, 12};
int main(void) {
/* 32-bit add hello world. */
{
__m128i input0 = _mm_set_epi32(1, 2, 3, 4);
__m128i input1 = _mm_set_epi32(5, 6, 7, 8);
__m128i output = _mm_add_epi32(input0, input1);
/* _mm_extract_epi32 mentioned at:
* https://stackoverflow.com/questions/12495467/how-to-store-the-contents-of-a-m128d-simd-vector-as-doubles-without-accessing/56404421#56404421 */
assert(_mm_extract_epi32(output, 3) == 6);
assert(_mm_extract_epi32(output, 2) == 8);
assert(_mm_extract_epi32(output, 1) == 10);
assert(_mm_extract_epi32(output, 0) == 12);
}
/* Now from memory. */
{
__m128i *input0 = (__m128i *)global_input0;
__m128i *input1 = (__m128i *)global_input1;
_mm_store_si128((__m128i *)global_output, _mm_add_epi32(*input0, *input1));
assert(!memcmp(global_output, global_expected, sizeof(global_output)));
}
/* Now a bunch of other sizes. */
{
__m128i input0 = _mm_set_epi32(0xF1F1F1F1, 0xF2F2F2F2, 0xF3F3F3F3, 0xF4F4F4F4);
__m128i input1 = _mm_set_epi32(0x12121212, 0x13131313, 0x14141414, 0x15151515);
__m128i output;
/* 8-bit integers (paddb) */
output = _mm_add_epi8(input0, input1);
assert(_mm_extract_epi32(output, 3) == 0x03030303);
assert(_mm_extract_epi32(output, 2) == 0x05050505);
assert(_mm_extract_epi32(output, 1) == 0x07070707);
assert(_mm_extract_epi32(output, 0) == 0x09090909);
/* 32-bit integers (paddw) */
output = _mm_add_epi16(input0, input1);
assert(_mm_extract_epi32(output, 3) == 0x04030403);
assert(_mm_extract_epi32(output, 2) == 0x06050605);
assert(_mm_extract_epi32(output, 1) == 0x08070807);
assert(_mm_extract_epi32(output, 0) == 0x0A090A09);
/* 32-bit integers (paddd) */
output = _mm_add_epi32(input0, input1);
assert(_mm_extract_epi32(output, 3) == 0x04040403);
assert(_mm_extract_epi32(output, 2) == 0x06060605);
assert(_mm_extract_epi32(output, 1) == 0x08080807);
assert(_mm_extract_epi32(output, 0) == 0x0A0A0A09);
/* 64-bit integers (paddq) */
output = _mm_add_epi64(input0, input1);
assert(_mm_extract_epi32(output, 3) == 0x04040404);
assert(_mm_extract_epi32(output, 2) == 0x06060605);
assert(_mm_extract_epi32(output, 1) == 0x08080808);
assert(_mm_extract_epi32(output, 0) == 0x0A0A0A09);
}
return 0;
Paso 3:ir y optimizar el código y punto de referencia que
La última y más importante y duro de paso, es, por supuesto, para usar las funciones intrínsecas para hacer que tu código sea rápido y, a continuación, de punto de referencia para su mejora.
Al hacerlo, es probable que requieren para aprender un poco sobre el x86 microarquitectura, que no me conozco a mí mismo.CPU vs IO enlazada probablemente será una de las cosas que se nos viene encima: Qué significan los términos "CPU" y "I/O bound" significa?
Como se mencionó en: https://stackoverflow.com/a/12172046/895245 esto casi inevitablemente de la lectura de Agner la Niebla de la documentación, la cual parece ser mejor que cualquier cosa que la propia Intel ha publicado.
Esperemos que sin embargo los pasos 1 y 2 que servirá como base para, al menos, experimentar con el funcional no los aspectos de rendimiento y ver rápidamente lo que las instrucciones están haciendo.
TAREAS:producir un mínimo ejemplo interesante de este tipo de optimización.
