Tafinho disse:
Não tem qualquer relação uma coisa com a outra. Não se usam bibliotecas SSE2, compila-se com istruções SSE2, e mesmo assim com resultados que variam entre o mediano e o muito mau.
Simplesmente não se pode gerar paralelismo onde ele não existe. A única coisa que o compilador pode fazer é "achar" esse paralelismo e modificar o código para tirar partido dele.
O Cell está muito relacionado com o actual processador da PS. Mas nada relacionado com o P4.
Bibliotecas SSE2 é produto da tua imaginação. O que eu disse é que se usam bibliotecas optimizadas para SSE2. Quando se diz isto significa que a biblioteca usa instruções SSE2. Se são optimizadas ou não depende da sua implementação.
Quanto ao resto, nada de mais errado. Provavelmente nunca usaste as SSE2 num P4, por exemplo. Compilando com uso de SSE2 quando possível consegue-se uma melhoria em Flops embora com um custo de precisão. O FPU dá 80bits enquanto as SSE2 são a 64bits. Bom, mas isto são outros quinhentos. Para se conseguir um bom speedup é necessario codificar à unha. Como isto é chato o comum é usar bibliotecas.
Bibliotecas com os algoritmos mais essenciais optimizados à pata para SSE2, coisas como FFT's, multiplicações entre matrizes vectores, etc é o que não falta por aí.
Uma bastante interessante é a Math Kernel Library da Intel.
http://www.intel.com/software/products/mkl/
Quando não se está por dentro de uma matéria convém não ultrapassar certos limites. Se quiseres aprender umas coisas podes ir à *escolinha* da Intel
https://shale.intel.com/SoftwareCollege/CourseDetails.asp?courseID=90
Mas como é para programadores avançados com conhecimentos de assembler e em particular sobre o conjunto de instruções SSE2 não sei se te vai ser útil.
Um exemplo. Em FFT's trabalha-se com complexos e obviamente que é necessário multiplicar números complexos pelo meio. Aqui vai exemplo de uma multiplicação de complexos codificada de forma a ser compilada na sua forma mais optimizada em SSE2.
#include <emmintrin.h>
__m128d ZMUL(__m128d a, __m128d b);
static __inline __m128d ZMUL(__m128d a, __m128d b)
{
__m128d ar, ai;
ar = _mm_unpacklo_pd(a, a); /* ar = [a.r a.r] */
ar = _mm_mul_pd(ar, b); /* ar = [a.r*b.r a.r*b.i] */
ai = _mm_unpackhi_pd(a, a); /* ai = [a.i a.i] */
ai = _mm_xor_pd(ai, _mm_set_sd(-0.0)); /* ai = [-a.i a.i] */
b = _mm_shuffle_pd(b, b, 1); /* b = [b.i b.r] */
ai = _mm_mul_pd(ai, b); /* ai = [-a.i*b.i a.i*b.r] */
return _mm_add_pd(ar, ai); /* [a.r*b.r-a.i*b.i a.r*b.i+a.i*b.r] */
}
Um bocado diferente de um, em fortran, COMPLEX a,b | a*b
Isto faz parte de uma conhecida biblioteca FFT.
Será que será economico e fresquinho?
