Multimedia - Departamento de Arquitectura y Tecnología de

Transcripción

TEMA 2: ARQUITECTURAS MULTIMEDIA.
• Título “publicitario”. Más correcto: Arquitecturas para paralelismo de datos.
• Origen: Arquitecturas Vectoriales. Problemas científico-técnicos: Expresión en vectores/matrices ->
igual operación sobre múltiples elementos.
• Procesador Vectorial: Registros e Instrucciones Vectoriales -> Múltiples datos por registros (ej. 256
doubles) e instrucciones que operan sobre registros completos.
Ej. DAXPY:
ldv
Ldv
Multv
Addv
Stv
vx,(rx)
vy,(ry)
vx,va,vx
vx,vx,vy
(ry),vx
• Análisis:
o Las unidades funcionales vectoriales cuando transcurre su latencia proporcionan un dato/ciclo.
o Una unidad func. empieza a operar en cuento dispone del primer dato (encadenamiento)
o El secuenciamiento es estático.
o Se permiten varias accesos simultáneos a distintas posiciones de memoria.
o Suposiciones: Latencias c- carga s- suma p- producto a- almacenamiento. Nº elementos = n
o Resultado: Duración= Latencia + n.
o En la tabla se da el último ciclo de cada fase.
Arquitectura y Tecnología de Computadores. Univ. Sevilla. .
ASP2: TEMA 2: ArquitecturasMultimedia : pág 1
Ldv
Ldv
Multv
Adv.
Stv
IF
1
2
3
3+c
3+c+p
ID
2
3
3+c
3+c+p
3+c+p+s
LAT
2+c
3+c
3+c+p
3+c+p+s
3+c+p+s+a
DATOS
2+c+n
3+c+n
3+c+p+n
3+c+p+s+n
3+c+p+s+a+n
Multimedia
• Similar a vectorial pero:
o Registros con menor número de elementos (de 2 a 16)
o Diferentes tipos de datos (int, float, double…)
o Operaciones realizadas sobre todo un registro a la vez (habitualmente) -> La temporización se
obtiene de forma análoga a los escalares pero teniendo en cuenta el número de iteraciones menor.
• DLX MM. Basado en SSE/SSE2 de Intel. Similar a otras arquitecturas multimedia.
• Modelo de registros:
M0 Float3
…
M7
Para double:
M0
…
M7
Float2
Float1
Float0
o Existen operaciones que operan sobre el registro entero y sobre su parte menos significativa.
o Emplearemos una notación similar a la de Intel para SSE/SSE2 pero con 3 operandos (DLX).
o Para instrucciones que operan sobre todos los elementos de un registro multimedia:
Insp{s|d|e} MMd,MMs1,MMs2
La p indica que la instrucción opera sobre múltiples datos empaquetados en un solo registro. Las
instrucciones que operan sobre 4 flotantes de simple precisión incluyen el identificador de datos p, las que
operan sobre datos de doble precisión incluyen el identificador de datos d y las que operan sobre datos
enteros (no existen en SSE) incluyen el identificador de datos e.
• Las instrucciones que operan sobre un único dato en la parte menos significativa del registro sustituyen la
p (packed) por s (scalar).
Tipos de Instrucciones
Aritméticas
• Similares a las existentes en modo escalar. Emplearemos notación vectorial C para los registros
Multimedia. Con esta notación si MM0={1.0,2.0,3.0,4.0}, 1.0 estaría en la componente 0 ( la más baja) del
registro.
• Multiplicación: mul{p|s}{s|d|e} MMd,MMs1,MMs2. ej: Mulps MM0,MM1,MM2
Si MM2={1.0,2.0,3.0,4.0} y MM1={0.5,-1.0,-1.0,0.25} tendríamos: MM0={0.5,-2.0,-3.0,1.0}
• División: div{p|s}{s|d|e} MMd,MMs1,MMs2. ej: divpd MM0,MM1,MM2
Si MM2={1.0, 4.0}, MM1={0.5,8.0} MM0={1.0,5.0} tendríamos: MM0={0.5,2.0}
• Suma: add{p|s}{s|d|e} MMd,MMs1,MMs2. ej: addss MM0,MM1,MM2
Si MM2={1.0,2.0,3.0,4.0}, MM1={0.5,-1.0,-1.0,0.25} MM0={1.0,2.0,3.0,4.0} tendríamos:
MM0={1.5,2.0,3.0,4.0}
• Resta: sub{p|s}{s|d|e} MMd,MMs1,MMs2. ej: subsd MM0,MM1,MM2
Si MM2={1.0, 4.0}, MM1={0.5,8.0} MM0={1.0,2.0} tendríamos: MM0={-0.5,2.0}
Lógicas
• Son operaciones entre registros bit a bit. Solo existen en versión de registro completo (p) y aunque puede
indicarse el tipo de dato {s|d|e} en realidad corresponden a la misma instrucción (opcode) para los 3 tipos
de datos.
• And: andp{s|d|e} MMd,MMs1,MMs2. ej: andps MM0,MM1,MM2
Si MM2={0xEFFFFFFF, 0xEFFFFFFF,xEFFFFFFF, 0xEFFFFFFF } y MM1={0.5,-1.0,-1.0,0.25}
tendríamos: MM0={0.5,1.0,1.0,0.25} //Reacuérdese que el bit más significativo es el signo en float.
• Or: orp{s|d|e} MMd,MMs1,MMs2. ej: orps MM0,MM1,MM2
Si MM2={0x80000000, 0x80000000, 0x80000000, 0x80000000} y MM1={0.5,-1.0,-1.0,0.25}
tendríamos: MM0={-0.5,-1.0,-1.0,-0.25}. // Este ejemplo calcula el valor absoluto cambiado de signo.
• Xor: xorp{s|d|e} MMd,MMs1,MMs2. ej: xorps MM0,MM1,MM2
Si MM2={0x80000000, 0x80000000, 0x80000000, 0x80000000} y MM1={0.5,-1.0,-1.0,0.25}
tendríamos: MM0={-0.5,1.0,1.0,-0.25}. //Este ejemplo cambia el signo.
Comparaciones
• Estas operaciones son muy similares a las instrucciones de comparación del dlx (scc Rd,Rs1,Rs2).
Emplearemos la terminología SSE denominándolas cmp{gt|ge|eq|le|lt|ne}{s|p}{s|d|e}.
• Estas instrucciones realizan la comparación componente a componente de los registros fuente. Si la
condición de comparación no se cumple la componente correspondiente del registro destino se pone a
valor 0. Si la condición se cumple todos los bits de la componente correspondiente del registro destino se
ponen a 1. Ejemplo: cmpgeps MM0,MM1,MM2. Si MM2={1.0,2.0,3.0,4.0 } y MM1={0.5,10.0,-1.0,25.0}
tendríamos: MM0={0,0xEFFFFFFF,0, 0xEFFFFFFF }
• Las instrucciones de comparación serán la base del procesado condicional en los procesadores con
extensiones multimedia. Este tema se estudiará en un apartado posterior.
Instrucciones de Movimiento de Datos básicas.
• En el caso de las instrucciones de carga y almacenamiento. Existen versiones vectoriales (p) y escalares
(s). Las versiones vectoriales ldmps{s|d|e} corresponden en realidad a una sola instrucción que transfiere
16 bytes desde memoria a registro. Las versiones vectoriales stmps{s|d|e} corresponden en realidad a una
sola instrucción que transfiere 16 bytes desde registro a memoria. Los modos de direccionamiento suelen
ser análogos a los de las instrucciones escalares.
• Las versiones escalares de las instrucciones de carga y almacenamiento transfieren 4 bytes en el caso de
operandos s o e y 8 bytes en el caso de operandos de doble precisión.
• Además de las instrucciones de carga y almacenamiento existen las instrucciones de barajado que permiten
seleccionar cada componente de un registro destino entre todas las de un registro fuente. El formato de
estas instrucciones es shufp{s|d|e} MMd,MMd, selector. El selector es una constante de 8 bits agrupados
en 4 parejas. Cada pareja nos indica que componente del registro fuente se situara en la componente
correspondiente del registro destino. Ej. Shufps MM1,MM2,%00011011. En este caso el selector debe
leerse como 00|01|10|11 o, en decimal, 0|1|2|3. La componente menos significativa del selector nos indica
de donde obtendremos la componente menos significativa del registro destino. En este ejemplo la
componente 2 (la más significativa se carga con la componente 0, la 2 con la 1, la 1 con la 2 y la 0 con la
3. Así si MM2={0.5,10.0,-1.0,25.0} tendríamos MM1={25.0,-1.0,10.0,0.5}.
• Un uso común de la instrucción shufps es replicar la componente menos significativa en todas las
componentes de un registro. Esto nos es necesario para multiplicar un vector por un escalar dado que no
existen instrucciones de multiplicación de escalar por vector en la mayoría de procesadores MM. Para
replicar la componente 0 de MM0 en todas sus componentes usamos la instrucción shufps MM0,MM0,0
• Ejemplo completo: bucle SAXPY. R4 señala al vector x, R1 señala al vector y, R2 señala el final del
vector x, R3 señala a la constante a.
Ldmss MM2,(R3)
//Carga a en la componente baja de MM2
Shufps MM2,MM2,0
//Replica a en todas las componentes de MM2
Saxpy: ldmps MM0,(R4) //Carga 4 componentes de x en MM0
Ldmps MM1,(R1) //Carga 4 componentes de y en MM1
Mulps MM0,MM0,MM2 //multiplica las componentes de x por a
Addps MM0,MM0,MM1 //y+a*x
Stmps (R1),MM0 //almacena y
Addi
R1,R1,16
Addi
R4,R0,16 //Actualiza punteros
Seq
R5,R0,R2 //Fin de x?
Beqz R5,Saxpy //si no hemos acabado seguimos
Procesado Condicional
• Cuando empleamos instrucciones multimedia no es posible implementar las estructuras if mediante saltos
dado que diferentes componentes del registro pueden satisfacer o no las condiciones. Esto implica que las
estructuras if deben implementarse transformando las dependencias de control en dependencias de datos
utilizando, para ello, las instrucciones lógicas y las instrucciones de comparación.
• El método para realizar esta transformación lo explicaremos mediante un ejemplo: Supongamos el código:
int i;float x[10000],y[10000];
for(i=0;i<10000;i++)
if (x[i]>0) x[i]=x[i]+y[i];
else x[i]=x[i]-y[i];
• En este caso debemos crear una mascara correspondiente al resultado de la comparación x[i]>0 y otra
correspondiente a la condición opuesta. Calculamos x[i] correspondiente a que se cumpla la condición if y
le hacemos and con la mascara correspondiente al cumplimiento de la citada condición. Calculamos x[i]
correspondiente a que se cumpla la condición else y le hacemos and con la mascara correspondiente al
cumplimiento de la citada condición. Hacemos or con los valores obtenidos de las dos operaciones and
(cada uno de ellos contiene ceros donde el otro contiene valores). Este valor es el que debemos almacenar.
• Este procedimiento se muestra en la figura siguiente.
•
Obtener mascara
Condición cierta
Obtener mascara
Condición falsa
Evaluar x para
condición cierta
Evaluar x para
condición falsa
And x cierta con
mascara cierta
And x falsa con
mascara falsa
Or x cierta con x
falsa para x a
almacenar.
El código suponiendo que R4 señala al vector x, R1 al vector y y R2 al final
del vector x sería el siguiente:
Bucle:
cmpneps
ldmps
Ldmps
Cmpgtps
Cmpleps
Addps
Subps
Andps
Andps
Orps
Stmps
Addi
Addi
Seq
Beqz
MM0,MM0,MM0 //Pone MM0 a 0
MM1,(R4)
//Carga 4 comp. de x.
MM4,(R1)
// Carga 4 comp. de y.
MM2,MM1,MM0 //MM2 mascara cond. cierta.
MM3,MM1,MM0 //MM3 mascara cond. falsa
MM5,MM0,MM4 //MM5 contiene x+y
MM6,MM0,MM4 //MM6 contiene x-y
MM5,MM2,MM5 //and cond. Cierta.
MM6.MM3,MM6 //and cond. Falsa
MM5,MM5,MM6 //Resultado a almacenar.
(R4),MM5
R4,R4,16
R1,R1,16
R3,R4,R2
R3,Bucle
Instrucciones de Carga y Almacenamiento específicas.
• Además de las instrucciones ldm{s|p}{s|d|e} y stm{s|p}{s|d|e} que básicamente se comportan como
instrucciones ld/st estándar la mayoría de procesadores con extensiones multimedia implementan algunas
instrucciones de carga y almacenamiento específicas para intentar aprovechar algunas peculiaridades de las
aplicaciones multimedia.
• En lo que respecta al almacenamiento muchas aplicaciones multimedia calculan datos que no
vuelven a reutilizarse hasta al cabo de un número grande de ciclos de reloj. Así, por ejemplo, en el
código C:
double x[1000],y[1000],z[1000];int i;
for(i=0;i<1000;i++) z[i]=x[i]+y[i];
Si tenemos un cache de datos de primer nivel de 8KB y los vectores x e y (o al menos la mayoría de
sus componentes) ya estaban previamente en el cache debido a un bucle anterior si utilizamos
instrucciones stmpd para almacenar las componentes de z, estas expulsaran a componentes de x e y
del cache empeorando notablemente el tiempo de ejecución de la aplicación.
En general cuando una aplicación multimedia escriba un dato, que no vaya a ser utilizado en el
futuro próximo no conviene escribirlo en el cache. La excepción ocurriría si el dato que vamos a
escribir ya está en el cache ya que en este caso, evidentemente, hemos de actualizarlo allí.
La solución empleada habitualmente en los procesadores con extensiones multimedia es el empleo de
instrucciones de almacenamiento no temporal que emplean una política de escritura en cache no
write allocate que, a diferencia de la política habitual write allocate, en el caso de un fallo de cache
en escritura escribe la componente ha almacenar directamente en memoria.
Nótese que, almacenemos con instrucciones de almacenamiento no temporal, componentes que están
en el cache, el comportamiento será idéntico a las instrucciones de almacenamiento convencionales.
Así, por ejemplo, para el código:
double x[1000],y[1000];int i;
for(i=0;i<1000;i++) x[i]=x[i]+y[i];
Cuando vayamos a escribir x la encontraremos en el cache pues ha sido cargada previamente por una
instrucción ldmpd. En este caso al acertar en el cache la instrucción de almacenamiento no temporal
tendrá el comportamiento habitual de un stmpd.
En las extensión multimedia propuesta la instrucción de almacenamiento no temporal sería
stnt{s|p}{s|d|e}.
• En el caso de las instrucciones de carga, en las aplicaciones multimedia es habitual que los
próximos datos que necesitemos no sean los últimos a los que hemos accedido. Muchas veces el
programador es el que mejor conoce que datos necesitará en el futuro. Por ello, en muchos casos,
conviene emplear instrucciones para llevar datos al cache y así asegurar que las cargas posteriores
acertarán en el mismo Una técnica tradicional en procesadores RISC consiste en emplear
instrucciones del tipo (recordar que R0 no puede escribirse pues vale siempre 0) para traer datos al
cache. El inconveniente de este tipo de instrucciones es que pueden generar excepciones (fallos de
página, accesos a zonas protegidas) no deseadas.
Para evitar el problema de las excepciones los procesadores con extensiones multimedia suelen
implementar instrucciones de precarga. Estas son equivalentes a ld R0,(Rx) pero no provocan
excepciones. Si el acceso provocara excepciones no se realizaría. Más tarde cuando el procesador
ejecute la instrucción de carga se realizará realmente el acceso a memoria y se serviran las
excepciones si se producen.
Temporización con Instrucciones Multimedia.
• A diferencia del caso vectorial las instrucciones multimedia se comportan como instrucciones
habituales de un procesador convencional no existiendo ninguna diferencia importante en el
cálculo del tiempo de ejecución de un programa. Las únicas diferencias estarían en el cálculo del
rendimiento en MFLOPs en cuyo caso hay que tener en cuenta que las operaciones mulps, addps,
etc realizan 4 operaciones en coma flotante mientras mulpd, addps, etc. realizan 2. Normalmente
las comparaciones y operaciones lógicas no se tienen en cuenta en el cálculo del rendimiento en
MFLOPs.
• Para aclarar el tema proponemos el siguiente ejemplo:
float x[1000],y[1000];int i;
for(i=0;i<1000;i++) if(x[i]<y[i]) x[i]=x[i]+y[i];
• Supongamos que tenemos un procesador superescalar de grado 3, que emplea el algoritmo de
Tomasulo y especulación hardware con buffer de reordenación. Tiene ventana deslizante y las
siguientes restricciones de emisión:
Tubería 1: Cualquier instrucción.
Tubería 2: Cualquier instrucción de distinto tipo que la emitida en la tubería 1.
Tubería 3: Cualquier instrucción de distinto tipo que las emitidas en tub1 y tub2.
Si una instrucción es un salto no puede emitirse ninguna instrucción posterior conjuntamente
con ella
• Pueden finalizar (fase C) 3 instrucciones/ciclo.
• Las estaciones de reserva, entradas de buffer de reordenación y buses comunes de resultados
existen en número suficiente para no originar bloqueos.
• Consideramos que los tipos de instrucción son: entera, ld/st, salto, fp y multimedia. Las cargas y
almacenamientos MM se consideran ld/st. El código sería (R1 apunta x, R2 a y, R3 fin de x):
bucle: ldmps MM0,(R1) //x -1
ldmps MM1,(R2) //y -2
cmpltps
MM2,MM0,MM1 //MM2 mascara cierta -3
cmpgeps MM3,MM0,MM1 //MM3 mascara falsa -4
addps
MM4,MM0,MM1 //Resultado cierto. El resultado falso es MM0. -5
andps
MM4,MM4,MM2 //and cierto. -6
andps
MM0,MM0,MM3 //and falso -7
orps
MM0,MM0,MM4 //resultado -8
stmps
(R1),MM0
//almaceno resultado en x -9
addi
R1,16 //10
addi
R2,16 //11
seq
R4,R1,R3 //12
beqz
R4,bucle
//13
• Las instrucciones están numeradas en los comentarios. La temporización vendría dada por la
siguiente tabla:
Ins IS
E
W
C
1
1
2-3
4
5
2
2
3-4
5
6
3
2
5-8
9
10
4
3
6-9
10
11
5
4
7-10
11
12
6
5
12-15 16
17
7
6
13-16 17
18
8
7
18-21 22
23
9
7
23-24 25
26
10 7
8
9
26
11 8
9
10
26
12 9
10
11
27
13 9
12
13
27
1
10
11-12 13
27
• Suponiendo que las emisiones se producen de forma análoga en la segunda iteración (no hay razón
para que sea distinta dado que no la única causa que evita la emisión son las restricciones a la
misma) el tiempo por iteración es de 10 ciclos.
• El IPC sería 13/10=1.3
• El rendimiento en MFlops vendría dado por: nºOperacionesFP/tiempo(en µs)=
=Operaciones_FP_por_iteración/tiempo_iteración(en µs)=
=(Operaciones_FP_por_iteración/ciclos_iteración)*F(en MHz)=
= 8/10*1000=800MFlops
• Tengase en cuenta que solo consideramos las operciones aritméticas (+,-,*,/) como Fops.
Consideraciones Adicionales
• ¿Qué ocurre si existe else? Ejemplo:
float x[1000],y[1000];int i;
for(i=0;i<1000;i++) if(x[i]<y[i]) x[i]=x[i]+y[i];else x[i]=x[i]-y[i];
• Aquí el resultado falso sería x[i]-y[i] en lugar de x[i]. Añadiríamos la instrucción para calcular
dicho resultado. El código quedaría como:
bucle: ldmps MM0,(R1) //x
ldmps MM1,(R2) //y
cmpltps
MM2,MM0,MM1 //MM2 mascara cierta
cmpgeps MM3,MM0,MM1 //MM3 mascara falsa
addps
MM4,MM0,MM1 //Resultado cierto.
Subps
MM5,MM0,MM1 //Resultado falso.
andps
MM4,MM4,MM2 //and cierto.
andps
MM0,MM5,MM3 //and falso
orps
MM0,MM0,MM4 //resultado
stmps
(R1),MM0
//almaceno resultado en x
addi
R1,16 //
addi
R2,16 //
seq
R4,R1,R3 //
beqz
R4,bucle
//
• ¿Qué ocurre si el else guarda el resultado en una variable distinta? Ejemplo:
float x[1000],y[1000];int i;
for(i=0;i<1000;i++) if(x[i]<y[i]) x[i]=x[i]+y[i];else y[i]=x[i]-y[i];
• A efectos prácticos existen dos resultados uno que se guarda en x[i] y otro en y[i]. El código sería
equivalente a:
float x[1000],y[1000];int i;
for(i=0;i<1000;i++)
if(x[i]<y[i]) {x[i]=x[i]+y[i];y[i]=y[i]}
else {x[i]=x[i];y[i]=x[i]-y[i];}
• Hemos de calcular los resultados falsos y ciertos para x y para y.
• El código quedaría como:
bucle: ldmps MM0,(R1) //x
ldmps MM1,(R2) //y
cmpltps
MM2,MM0,MM1 //MM2 mascara cierta
cmpgeps MM3,MM0,MM1 //MM3 mascara falsa
addps
MM4,MM0,MM1 //Resultado cierto x. Falso x en MM0
Subps
MM5,MM0,MM1 //Resultado falso y. Cierto y en MM1
andps
MM4,MM4,MM2 //and cierto y
andps
MM0,MM0,MM3 //and falso x
orps
MM0,MM0,MM4 //resultado x
stmps
(R1),MM0
//almaceno resultado en x
andps
MM4,MM1,MM2 //and cierto y
andps
MM0,MM5,MM3 //and falso y
orps
MM0,MM0,MM4 //resultado y
stmps
(R2),MM0
//almaceno resultado en y
addi
R1,16 //
addi
R2,16 //
seq
R4,R1,R3 //
beqz
R4,bucle
//
• Esta misma técnica puede aplicarse cuando se calculan múltiples variables en el if y/o en el
else.

Multimedia - Departamento de Arquitectura y Tecnología de

Transcripción

Documentos relacionados

La Importancia de la Integración Familiar