Cronologia. Extensões SIMD. SIMD - Single Instruction Multiple Data. Dados multimédia. Extensões SIMD. MMX - Matrix Math extensions => SIMD.

(1)

Exten s ões S IM D Página 1

Extensões SIMD

Miguel Leitão v0.8 - 2000, v1.1 - 2002, v2.0 - 2006, V2.1 - 2010 Exten s ões S IM D Página 2

Cronologia

Z80 Z8000 Z80000 6800 PowerPC 601

PowerPC A35 Apache

S/370 R2000 T800 T900 Stanford MIPS R4000 R3000 R8000 R10000 R12000 R14000 68000 32032 6x86 PA-Risc 29000 2901 8x300 ARM K5 K6 Athlon 68020 68030 68040 68060 801 RISC 1 88000 PIC 16x/17x Sparc SuperSparc UltraSparc Sparc64 Alpha 21064 Alpha 21364 Alpha 21264 MicroVAX VAX PDP-11 2000 1995 1990 1985 1980 1975 8086 8085 8088 8080

Intel Motorola IBM MIPS INMOS DEC HP AMD NS/Cyrix Outros

80286 80386 80486 MMX SSE SSE2 Enh 3DNow AltiVec MAX-1 3D-Now VIS MDMX Pentium Pentium Pro Pentium II Pentium III Pentium 4Itanium Alpha 21164 Power 1 Power 2 Power 3 T414 PowerPC 604 Exten s ões S IM D Página 3

SIMD -

Single Instruction Multiple Data

Conceito deprocessamento paralelo

aplicado nos sistemas que possuem várias Unidades Operativas coordenadas por

uma única Unidade de Controlo.

– Vector processors – Array processors

Exemplo:ILLIAC IV (1972)

– 1 Unidade de Controlo – 64 Unidades Executivas de 64 bits

ALU Exten s ões S IM D Página 4

Dados multimédia

Tipos de dados de dimensão reduzida:

8 bits / amostra de som de baixa qualidade

16 bits / amostra de som de alta qualidade

8 bits / pixel de imagem monocromática

16 bits / pixel de imagem colorida

8 bits / componente de cor / pixel de imagem de alta qualidade

Pequenos ciclos com grande número de repetições

Multiplicações e acumulações frequentes

Algoritmos de elevado peso computacional

Operações facilmente paralelizáveis

Grande número de dados tratados de forma independente

=> SIMD. Exten s ões S IM D Página 5

Extensões SIMD

 Unidades computacionais SIMD integradas em µProcessadores.

– Associadas a um conjunto próprio de instruções. – Eventualmente com registos dedicados.

 Processamento de vectores de dados

 Exemplos:

– MMX, o SEE e o SEE2 da Intel. – AltiVec integrado no PowerPC. – 3D-Now! da AMD.

– O VIS integrado na família SPARC – O MAX-1 da HP

– O MDMX dos processadores Mips

a3 a2 a1 a0 b3 b2 b1 b0 a3opb3a2opb2a1opb1a0opb0 op op op op op Exten s ões S IM D Página 6

MMX - Matrix Math eXtensions

 Designação inicial:

– MMX - Matrix Math eXtensions – Intel Pentium MMX (1996)

 8 Registos MMX (MM0- MM7)  47 Novas instruções MMX

 Tratamento de dados empacotados do tipo inteiro.  Funcionalidades orientadas para dados multimédia:

– Aritmética com saturação – Conversão de formatos

(2)

Registos MMX

 8 “novos” registos  64 bits / registo

 mapeados sobre os registos FPU

mm0 mm1 mm2 mm3 mm4 mm6 mm5 mm7 80 bits Registos FPU 64 bits Registos MMX Exten s ões S IM D Página 8

Tipos de dados MMX

Quadword (64 bits) Packed Doublewords (2 x 32 bits) Packed Words (4 x 16 bits) Packed Bytes (8 x 8 bits)

0 63 Exten s ões S IM D Página 9

Instruções MMX

47 novas instruções MMX: Instruções Aritméticas Instruções de Comparação Instruções de Conversão Instruções Lógicas Instruções de Deslocamento Instruções de Transferência de Dados Instrução de Inicialização (EMMS)

Instruções MMX

Packed

P

Operação

XXX

[

S]

com Saturação

[U]

Unsigned

[tipo]

Tipo de dados: “B” - Byte “W” - Word “D” - Doubleword “Q” - Quadword (8) (16) (32) (64)

OP DEST(operando esquerdo) SRC(operando direito)

<=>

DEST(operando esquerdo) = DEST OP SRC(operando direito)

Exten s ões S IM D

Soma de dois vectores

A

B

0x40 0x7F

A+B

Aritmética com saturação

A

B

0x40

A+B

com wraparound A+B

(3)

Soma sem saturação

MM3

MM3 MM4

a3

a2

a1

F FF Fh

b3

b2

b1

8000h

a3+b3

a2+b2

a1+b1

7 FF Fh

+

paddw mm3, mm4

FFFFh + 8000h = 17FFFh Exten s ões S IM D Página 14

Soma com saturação sem sinal

MM3

MM3 myBuffer

a3

a2

a1

FFFFh

b3

b2

b1

8000h

a3+b3

a2+b2

a1+b1

FFFFh

+

paddusw mm3, [myBuffer]

Multiplicação

MM3 MM3 MM4 0002h 0100h 5622h 1000h 0030h 3A65h 0200h 8000h 0000h 003Ah 00ACh 0800h

*

pmulhw mm3, mm4

1000h * 8000h = 0800 0000h Exten s ões S IM D Página 16

Multiplicação

MM3 MM3 MM4 0002h 0100h 5622h 1000h 0030h 3A65h 0200h 8000h 0060h 6500h 4400h 0000h

*

pmullw mm3, mm4

1000h * 8000h = 0800 0000h Exten s ões S IM D Página 17

Soma de produtos

MM3 MM3 MM4 a3 a2 a1 a0 b3 b2 b1 b0 a3*b3+a2*b2 a1*b1+a0*b0

*

pmaddwd mm3, mm4

Comparação

MM3 MM3 MM4

21

56

88

76

34

12

92

76

0000h

>?

FFFFh

pcmpgtw mm3, mm4

(4)

Desempacotamento

punpckhbw mm3, mm4

MM3 MM3 MM4 B4 A4 B5 A5 B6 A6 B7 A7 B0 B1 B2 B3 B4 B5 B6 B7 A0 A1 A2 A3 A4 A5 A6 A7 Exten s ões S IM D Página 20

3DNow!

 Conjunto de instruções SIMD para o processador AMD K6-2(Fev/99).

 Extensão à tecnologia MMX, já disponível nesta família.

 Permite o tratamento de dados de vírgula flutuante de precisão

simples (32 bits).

 Utiliza os registos MMX:

 Operações adicionais disponibilizadas:

• comparações, • somas, • subtracções, • multiplicações

• inversos (para a implementação de divisões)

2 x Floating Foint (4 x 32 bits)

0 63 32 31 Exten s ões S IM D Página 21

SSE - Streaming SIMD Extensions

 8 novos registos de 128 bits (XMM0 – XMM7),

 Novo registo de 32 bits (MXCSR). bits de controlo e de status.

 Novo tipo de dados: 4 x vírgula flutuante de precisão simples

 Instruções SIMD de 128 bits para valores em vírgula flutuante

empacotados nos registos XMM (XMM0-XMM7).

 Instruções SIMD adicionais de 64 bits para inteiros empacotados

nos registos MMX (MM0-MM7).

 Instruções para controlo da cache de dados.

xmm0 xmm1 xmm2 xmm3 xmm4 xmm6 xmm5 xmm7 128 bits

4 x Floating Foint (4 x 32 bits)

Processamento Empacotado / Escalar

a3 a2 a1 a0 b3 b2 b1 b0 a3opb3a2opb2a1opb1a0opb0 op op op op op a3 a2 a1 a0 b3 b2 b1 b0 a3 a2 a1 a0opb0 op op

Modo Empacotado Modo Escalar

Sufixo da instrução:

PS– para processamento empacotado.

SS– para processamento escalar.

Mistura de dados

C0 C1 C2 C3 XMM3 B0 B1 B2 B3 XMM3 A0 A1 A2 A3 XMM4 mask Mux Mux

shufps xmm3, xmm4, mask

Comparação de vectores

 Em C float a[4], b[4] int i, c[4]; // a[] contém 4.9 6.3 3.1 25.6 // b[] contém 9.4 1.8 3.5 12.7

for (i = 0;i < 4; i++ ) c[i] = a[i] < b[i];

 Utilizando SSE

; xmm3 contém 4.9 6.3 3.1 25.6 ; xmm4 contém 9.4 1.8 3.5 12.7

; compara xmm3 com xmm4 cmpps xmm3, xmm4, 1;

; coloca a máscara em eax movmskps eax, xmm3;

(5)

Instruções CMPPS e MOVMSKPS

4.9 6.3 3.1 25.6 9.4 1.8 3.5 12.7 11...1 00...0 11...1 00...0 0 1 0 1 0 0 0 0 0 0 … 0 cmpps XMM3 XMM3 XMM4 EAX movmskps Exten s ões S IM D Página 26

MAX

 MAX-1 introduzido pela HP no PA-RISC 7100LC em 1994  Seguiu-se o MAX-2 no processador PA-8000.

 Conjunto de instruções SIMD para tratamento de inteiros de 16 bits empacotados nos registos de uso geral.  Inclui funcionalidades SIMD para:

– somas, – subtracções, – deslocamentos.

Multimedia Acceleration eXtensions

AltiVec

 Extensão SIMD do Processador PowerPC  Introduzida no PowerPC G4 no final de 1998  Conjunto de 32 registos de 128 bits que podem conter:

– 16 caracteres ou inteiros de 8 bits, com ou sem sinal. – 8 inteiros de 16 bits, com ou sem sinal.

– 4 inteiros de 32 bits, com ou sem sinal.

– 4 números representados em vírgula flutuante de 32 bits.

MDMX

 SGI, 1999

 Extensões Multimédia para os processadores MIPS  Incluí um acumulador de produtos de 192 bits.  Utiliza os registos da unidade de vírgula flutuante.

 Conjunto de Instruções SIMD da SUN para o UltraSparc.  Incluí instruções de complexidade superior:

• pdist - soma das diferenças acumuladas. Útil para MPEG • Transferências de blocos de 64 Bytes Memória / grupos de registos

Mips Digital Media eXtensions

VIS

Visual Instruction Set

ADSP TigerSHARC

 Dois conjuntos executivos (PEx e PEy), com:

• unidade lógica e aritmética (ALU); • multiplicador / acumulador (MAC); • unidade de deslocamento (Shifter); • conjunto de registos próprios.

 executa a mesma instrução nos dois conjuntos  algumas instruções podem especificar uma divisão das

unidades executivas

ALU MAC Shifter ALU MAC Shifter

Instrução MAC SIMD

a7 a6 a5 a4 a3 a2 a1 a0 Exten s ões S IM D Página 30

SSE 2

 Introduzidas no processador Intel Pentium 4(Nov/2000).

 144 novas instruções

(versões de 128 bits das instruções MMX)

 Novos tipos de dados nos registos XMM:

– 2 x vírgula flutuante de dupla precisão – 4 x inteiros de 32 bits (doubleword ) – 2 x inteiros de 64 bits (quadword) – 4 x inteiros de 32 bits (doubleword) – 8 x inteiros de 16 bits (word) – 16 x inteiros de 8 bits (byte)

(6)

SSE 3

 alargamento das capacidades SIMD disponibilizadas pelas extensões SSE e SSE2.

 Introduzida em 2004 na versão Prescott do Pentium 4.  13 novas instruções.

 Processamento de dados num Modelo Horizontal

 Processamento Assimétrico Exten s ões S IM D Página 32

SEE 3 – Processamento Horizontal

SSE 3 - Processamento Assimétrico

SSSE3

 SSSE3 = Supplemental Streaming SIMD Extensions 3  Actualização das extensões SSE3

 Permite alargar as possibilidades de processamento horizontal de dados empacotados nos registos XMM.  Está disponível nos processadores

– Intel CORE – Intel CORE Duo

SSE4

 disponibiliza 54 novas instruções e

 começou a ser incorporada nos processadores da Intel em 2008.

 SSE4.1

– Um subconjunto de 47 destas instruções foi disponibilizado nos processadores da micro-arquitectura Penryn.

 SSE4.2

– conjunto completo das instruções SSE4.1 com mais sete instruções adicionais

– está disponível em todos os processadores com a

micro-arquitectura Nehalem (Core I3, I5 e I7). Exten

s ões S IM D

SSE 4.1

 Duas instruções para multiplicação de DoubleWords empacotadas.

 Duas instruções para produto escalar de vectores.

 Uma instrução para leitura de dados em fluxo (streaming).

 Seis instruções para cópia e junção condicional de dados

empacotados.

 Oito instruções para determinação de máximo e mínimo.

 Quatro instruções para arredondamento de valores de vírgula

flutuante.

 Sete instruções de transferência de dados de e para os registos

XMM.

 Doze instruções para conversões de formatos de inteiros

empacotados.

 Uma instrução para cálculo da soma de diferenças absolutas (SAD).

(7)

SSE 4.2

 As sete instruções disponibilizadas adicionalmente nas unidades SSE4.2 incluem

 instruções vocacionadas para o processamento texto e de cadeias de caracteres.

 instruções que facilitam o processamento SIMD de dados localizados nos registos de uso geral.

AVX

 Advanced Vector Extensions (AVX)

 Nova unidade computacional SIMD

 A ser incorporada nos processadores Intel em 2011  Alargamento dos registos para 256 bits (Y00-Y15)

Combinação de imagens

70% + 30% = X3 X2 X1 X0 X0 Y0 X1 Y1 X2 Y2 X3 Y3 - -- -- -- -Y3 Y2 Y1 Y0 UNPACK

Desempacotamento

Combinação de imagens

X3 X2 X1 X0 70% 70% 70% 70% X3’ X2’ X1’ X0’ * * * * Y3 Y2 Y1 Y0 30% 30% 30% 30%

Y3’ Y1’ Y0’

PMULH * * * *

Escalamentos

Combinação de imagens

R3 PACK R2 R1 R0

+

R0 R1 R2 R3

-Adição e empacotamento

Combinação de imagens

; mm0 contém 0 ; mm7 contem 4CCD 4CCD 4CCD 4CCD h (30% 30% 30% 30%) ; mm6 contém B333 B333 B333 B333 h (70% 70% 70% 70%) ; mm1 contém 8 pixels da imagem X

; mm2 contém 8 pixels da imagem Y ; preserva pixels

movq mm3, mm1

movq mm4, mm2

; trata 4 pixels menos significativos

punpcklbw mm1, mm0

punpcklbw mm2, mm0

pmulhw mm1, mm6 ; escala imagem X

pmulhw mm2, mm7 ; escala imagem Y

paddusw mm1, mm2

; trata 4 pixels mais significativos

punpckhbw mm3, mm0

punpckhbw mm4, mm0

pmulhw mm3, mm6 ; escala imagem X

pmulhw mm4, mm7 ; escala imagem Y

paddusw mm3, mm4

; empacota 8 pixels da imagem final para mm1

(8)

Sobreposição condicional

X1!=green X5 … green X2=green green X3!=green green X4=green green 0000h FFFFh 0000h FFFFh =? =? =? =?

+ =

X + Y = S

Obtenção da máscara

Exten s ões S IM D Página 44 X1 X2 X3 X4 0000h FFFFh 0000h FFFFh X1 0000h X3 0000h pandn pandn pandn pandn

Y1 Y2 Y3 Y4

0000h FFFFh 0000h FFFFh

0000h Y2 0000h Y4 pand pand pand pand

Sobreposição condicional

Selecção por máscara

Sobreposição condicional

X1 Y2 X3 Y4 POR

Todo este processo poderia ser aplicado a imagens de 8 bits, tratando 8 pixels de cada vez !!

Adição das imagens mascaradas

Somas de produtos

)

(

)

(

7 0

i

c

i

a

x

i







 a0 a1 a2 a3 c0 c1 c2 c3 pmaddwd * * * * a4 a5 a6 a7 c4 c5 c6 c7

a0*c0 + a1*c1 a2*c2 + a3*c3 a4*c4 + a5*c5 a6*c6 + a7*c7

* * * * t3 t1 t2 t4 Número de instruções sem tecnologia MMX Número de instruções MMX Load 16 4 Multiply 8 2 Shift 0 1 Add 7 2 Store 1 1 Total 32 10 paddsd paddsd psrlq 32 … … x t1+t3 t1+t3 t2+t4 Exten s ões S IM D

Produto de matrizes

Número de instruções sem tecnologia MMX Número de instruções MMX Load 32 6 Multiply 16 4 Add 12 2 Miscellaneous 8 12 Store 4 4 1 'a0xa1ya2za3 x                                                             1 3 2 1 0 3 2 1 0 3 2 1 0 3 2 1 0 z y x d d d d c c c c b b b b a a a a w z y x Perspectiva Translacção Rotação e escalamento Exten s ões S IM D

Biblioteca Intrínseca

 Ferramenta de desenvolvimento para MMX e SSE.  Uma função C para cada instrução MMX ou SSE.

Exemplo: soma de 2 vectores de 4 valores de vírgula flutuante

__m128 a, b, c; a = _mm_set_ps(6.0, 4.4, 37.8, 1.0); b = _mm_set_ps(3.0, 2.0, 1.0, 53.2); c = _mm_mul_ps(a, b); ... Resultado: c = ( 18.0, 8.8, 37.8, 53.2 );

(9)

Classes SIMD Vec

#include <dvec.h> ... F32vec4 a(6.0, 4.4, 37.8, 1.0); F32vec4 b(3.0, 2.0, 1.0, 53.2); F32vec4 c; ... c = a * b; ... Resultado: c = ( 18.0, 8.8, 37.8, 53.2 ); Tipo de dados: “ ” - Inteiros “ ” - Vírgula flutuanteIF

T

Sinalidade: “” - indefinido “ ” - com sinal “ ” - sem sinalsu

[

sig

]

Data size: ( 8, 16, 32, 64 )

ds

vec

nd

Número de dados: ( 1, 2, 4, 8, 16 )

Instruções MMX e vírgula flutuante

 As secções MMX devem ser concluídas com a instrução EMMS.

 As secções de vírgula flutuante devem deixar a stack limpa.

FP_code: ..

.. (* deixa a stack FP limpa *) MMX_code:

..

EMMS (* limpa a contexto MMX *) FP_code 1:

..

.. (* deixa a stack FP limpa *)

Alinhamento dos dados

Dados desalinhados na memória =>

=> Aumento de acessos à memória

Soluções

 Pré copiar os dados para zonas alinhadas (duplicação)

 Impor ao compilador o alinhamento dos dados

 Alinhar os apontadores:

new_ptr = malloc(new_value * sizeof (var_struct) + 8); mem_tmp = new_ptr;

mem_tmp /= 8;

new_tmp_ptr = (var_struct*) ((mem_tmp+1) * 8);

new_tmp_ptr mem_tmp*8 new_ptr Exten s ões S IM D Página 52

Alinhamento da Stack

Prologue:

push ebp ; preserva ebp mov ebp, esp ; stack ptr sub ebp, 4 ; aloca espaço para

; stack ptr and ebp, 0FFFFFFF8 ; alinha a 64 bits mov [ebp], esp ; preserva stack ptr mov esp, ebp ; alinha esp …

epilogue: …

mov esp, [ebp] ; recupera esp pop ebp ; recupera ebp ret Exten s ões S IM D Página 53

Acessos inerentemente desalinhados

Se o acesso aos elementos j e seguintes for alinhado, então o acesso aos elementos j+1 e seguintes será desalinhado.

Soluções

 Utilizar várias cópias do buffer.

 Aumentar o número de dados a tratar,

 Fazer sempre acesso alinhados

 Anular efeito dos dados em excesso

-> colocar zeros no vector coef

Exemplo: filtro FIR

 







 

     n p p coef p j data i fir 0 * 1 1

 







 

   n p p coef p j data i fir 0 * Exten s ões S IM D Página 54

Simulação de tráfego

d0 0 d1 _d2 d3 _d4 0 v0 1 2 3 4 d0 d_vec d1 d2 d3 d4 d5 d6 d7 v0 v_vec v1 v2 v3 v4 v5 v6 v7

float s_vec[N_CARS+5]; // Posições longitudinais float v_vec[N_CARS+5]; // Velocidades longitudinais

(10)

Simulação de tráfego

__m128 d_dist = _mm_set_ps(D_DIST, D_DIST, D_DIST, D_DIST); __m128 dt = _mm_set_ps(DT, DT, DT, DT);

for( int i=0 ; i<N_CARS ; i+=4 ) { __m128 s, s_frt, d_ftr, dt;

s = _mm_load_ps(s_vec+i); // Posição de 4 carros

s_ftr = _mm_loadu_ps(s_vec+i+1); // carros da frente d_ftr = _mm_sub_ps(s_frt, s); // distância frente d_ftr = _mm_sub_ps(d_ftr, d_dist); // erro de posição

a = ... // aceleração

v = _mm_load_ps(v_vec+i);

v = _mm_add_ps(v, _mm_mul_ps(a, dt)); // v = v + a.dt

_mm_store_ps(v_vec+i, v); // guarda velocidade

s = _mm_add_ps(s, _mm_mul_ps(v, dt)); // s = s + v.dt

_mm_store_ps(s_vec+i, s); // guarda posição

} Exten s ões S IM D Página 56

Estruturas de dados

Programação orientada a objectos: Arrays de estruturas

Aplicação de SIMD: Estruturas de arrays

d0 d_vec d1 d2 d3 d4 d5 d6 d7 v0 v_vec v1 v2 v3 v4 v5 v6 v7 c_vec d1 v1 c1 d2 v2 c2 d3 v3 c3 d4 v4 c4 d5 v5 c5 d0 v0 c0 Exten s ões S IM D Página 57

Filtro FIR

Implementação sequencial FIR() { int i, k;

for (i=0; i<BLOCKLEN; i++) {

float acc = 0.; for (k=0; k<ORDER; k++)

acc += Buf[i+k] * taps[k]; Output(acc); } } ORDER Taps ... BLOCKLEN Buf Exten s ões S IM D Página 58

Paralelizando o ciclo interno...

FIR2() { int i, k; float *soma_p; __m128 v_soma; soma_p = (float*)&v_soma; for (i=0; i<BLOCKLEN; i++) { float acc; v_soma = _mm_set1_ps(0.); for (k=0; k<ORDER; k+=4) { __m128 a, b, c; a = _mm_loadu_ps(Buf+i+k); b = _mm_load_ps(taps+k); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); }

acc = soma_p[0] + soma_p[1] + soma_p[2] + soma_p[3]; Output(acc);

} }

Problemas se ORDER não é múltiplo de 4

Soma de 4 totais parciais

Paralelizando o ciclo externo...

FIR3() { int i, k; float *soma_p; __m128 v_soma; soma_p = (float*)&v_soma; for (i=0; i<BLOCKLEN; i+=4) { float acc; v_soma = _mm_set1_ps(0.); for (k=0; k<ORDER; k++) { __m128 a, b, c; a = _mm_loadu_ps(Buf+i+k); b = _mm_set1_ps(taps[k]); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); } Output(soma_p[0]); Output(soma_p[1]); Output(soma_p[2]); Output(soma_p[3]); } Menos inicializações Exten s ões S IM D

Replicação dos dados

FIR4() { int i, k; float *soma_p; __m128 v_soma; float Buf1_[BLOCKLEN+ORDER+4], Buf2_[BLOCKLEN+ORDER+4], Buf3_[BLOCKLEN+ORDER+4]; float *Buf1, *Buf2, *Buf3;

Buf1 = Buf1_+3; Buf2 = Buf2_+2; Buf3 = Buf3_+1; memcpy(Buf1, Buf, BLOCKLEN*sizeof(float)); memcpy(Buf2, Buf, BLOCKLEN*sizeof(float)); memcpy(Buf3, Buf, BLOCKLEN*sizeof(float)); soma_p = (float*)&v_soma;

for (i=0; i<BLOCKLEN; i+=4) {

...

Também é possível replicar os coeficientes... Buf

Buf3 Buf2 Buf1

(11)

Acessos ao buffer alinhado

... for (k=0; k<ORDER; k+=4) { m128 a, b, c; a = _mm_load_ps(Buf+k+i); b = _mm_set1_ps(taps[k]); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); a = _mm_load_ps(Buf1+k+i+1); b = _mm_set1_ps(taps[k+1]); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); a = _mm_load_ps(Buf2+k+i+2); b = _mm_set1_ps(taps[k+2]); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); a = _mm_load_ps(Buf3+k+i+3); b = _mm_set1_ps(taps[k+3]); c = _mm_mul_ps(a,b); v_soma = _mm_add_ps(v_soma,c); } acessos alinhados !! Exten s ões S IM D Página 62

Onde aplicar paralelismo ?

 Muitos algoritmos trabalham pequenos blocos de dados.

– Filtros: 8 amostras, 3x3 / 5x5 – DCT: 8x8

=> Paralelismo limitado

 Nº de blocos pode ser grande

– Paralelizar tratamento de blocos pode ser mais interessante

Não limitar a exploração de paralelismo aos ciclos mais interiores

Cuidados

 Estratégia de paralelismo

• não considerar apenas os ciclos mais internos.  Estruturas de dados

• Estruturas de arrays mais adequadas do que arrays de estruturas. • Itens tratados em paralelo colocados sequencialmente.  Alinhamentos

 Partilha de recursos com outras unidades  Ferramentas automáticas

• Compiladores paralelizantes • Bibliotecas

– Nem sempre são eficazes

Futuro

 Mais unidades executivas ?  Registos mais largos ?

– Maiores dificuldades de paralelismo

 Instruções de complexidade superior

– Carregamento de grupos de registos (4x4 vírgula flutuante) – Produtos 4x4 . 4x1

– Empacotamento / Desempacotamento / Mistura mais eficientes – Funções trigonométricas

 Melhores ferramentas de paralelização automática

Mais informação

 MMXTM_{Technology Technical Overview, May 1999}

ftp://download.intel.com/ids/mmx/MMX_Manual_Tech_Overview.pdf

 Intel ArchitectureMMX™ Technology, Programmer's Reference Manual,

March 1996,

 MMX™ Technology Developer's Guide, May 1999

• Intel® 64 and IA-32 Architectures - Software Developer’s Manual,

http://www.intel.com/Assets/PDF/manual/253665.pdf

 H. Nguyen and L. K. John, Exploiting SIMD Parallelism in DSP and

Multimedia Algorithm Using the AltiVec Technology, International Conference on Supercomputing (ICS99)