#define MAX 1024 void escala_vect (float A[MAX], float B[MAX], float k) { int i; for (i=0; i < MAX; i++) B[i]=k*A[i]; }

Transcripción

1 PROBLEMA 1 Memoria Cache (10 puntos) Supongamos un sistema con un procesador que lanza direcciones de 32 bits. Dispone de dos caches, una para instrucciones y otra para datos, de 8 KBytes cada una. La cache de datos está organizada en bloques de 32 bytes, correspondencia directa. Considera la función: #define MAX 1024 void escala_vect (float A[MAX], float B[MAX], float k) { int i; for (i=0; i < MAX; i++) B[i]=k*A[i]; Supondremos que el tipo de dato float ocupa 4 bytes, que los vectores A y B están contiguos en memoria principal a partir de 0x7fff3380 (ver figura 1) y que las variables i y k se guardan en registros (no se almacenan en memoria principal). Considera 2 políticas distintas en la cache de datos: P1: escritura inmediata (write through) en acierto de escritura, no write allocate, no fetch en write miss (write around) en fallo de escritura. P2: escritura retardada (write-back) en acierto de escritura, y write allocate, fetch on write-miss (política convencional) en fallo en escritura. Teniendo en cuenta solamente los accesos de datos generados por la función escala_next(), calcula las tasas de fallos de datos. Supón que la cache de datos está inicialmente vacía. POLÍTICA TASA DE FALLOS BREVE EXPLICACIÓN / CUENTAS p1 p2

2 PROBLEMA 2 Estudio de un procesador segmentado (30 puntos) Considera un procesador en orden que ejecuta un repertorio de instrucciones como el subsparc visto en clase (arquitectura ld/st de 32 bits) con el añadido de instrucciones aritméticas complejas que requieren 2 ciclos de cálculo (alu). Las 6 etapas de la segmentación son las siguientes: E1: cache de isntrucciones: lectura de tag e isntrucción (B). E2: decodificación y control de dependencias (D); evaluación de condición y cálculo de salto condicional (relativo al PC). Esta etapa y la anterior son las únicas en las que puede bloquearse una instrucción. E3: lectura de banco de registros o de la red de cortocircuitos (L). E4: ALU(A); cálculo de salto incondicional; cálculo de memoria (@). E5: transparente para operaciones sencillas de ALU; ALU 2 para operaciones complejas de ALU (A2); lectura de cache de datos y comprobación de acierto/fallo (M). En caso de store, la escritura es en el ciclo siguiente. E6: escritura en banco de registros (ciclo completo). Escritura en cache de datos (E). Al detectar un riesgo en E2, el procesador bloquea la búsqueda y decodificación de instrucciones hasta que desaparece el riesgo. Se suponen los cortocircuitos necesario para minimizar las detenciones. Una instrucción dependiente de un load sólo pasa a E3 cuando se confirma que el load ha acertado en cache. Las instrucciones de salto condicional e incondicional son 1-retrardadas. Las operaciones aritméticas complejas están completamente segmentadas (latencia de iniciación=1). Importante: en los diagramas temporales no utilices E1, E2 para referenciar las etapas, sino la actividad que realizan (B,D,L ) a) Salto incondicional: calcula los ciclos perdidos. Dibuja diagramas de tiempos y aclara que instrucciones deben ser emuladas, detenidas b) Salto condicional. b1) Calcula los ciclos perdidos para los casos de salto no tomado y de salto tomado. Supón que la instrucción anterior al salto no modifica los códigos de condición. Dibuja el diagrama de tiempos (con uno es suficiente para ambos casos) y aclara que instrucciones deben ser anuladas, detenidas b2) Calcula los ciclos perdidos para los casos de salto no tomado y de salto tomado. Supón que la instrucción anterior al salto es una aritmética sencilla que sí modifica los códigos de condificón. Dibuja el diagrama de tiempos (con uno es suficiente para ambos casos) y aclara que instrucciones deben ser anuladas c) Calcula los ciclos que debe detenerse la siguiente isntrucción a un ld en caso de ser dependiente. Suponer acierto en cache de datos. Adjuntar diagrama. d) En caso de fallo en la cache de datos se necesitan 4 ciclos más para leer el bloque correspondiente en el 2º nivel de cache (siempre será acierto y el hardware lo sabe) y escribirlo en el primer nivel. En paralelo con esta última acción se realiza el suministro a la instrucción dependiente (si lo hay). Calcular la penalización (ciclos adicionales) debidos al fallo) y dibujar el diagrama de tiempos para este código: i: ld r1, ; Fallo en L1 de calculada por ld i+1: add r2, r3, r1; r2=r3+r1 e) Dibuja una dependencia alu compleja/uso entre una instrucción i y una instrucción i+k, k={1,2,3,4, mostrar los cortes utilizados y los ciclos de detención en cada caso. Recuerda: el diagrama condensa los posibles casos, no representa como se secuencia el código.

3 f) Se ejecuta un programa de prueba y se observa la distribución de instrucciones mostrada en la tabla. También se sabe que el 10% de los loads fallan en LiD. Supongamos que no hay detenciones por riesgo productor-consumidor (incluyendo aritmética-salto condicional). Sólo hay detención por fallo en cache y por riesgos de control. Calcula los ciclso por instrucción (CPI): CPI = INSTRUCCIÓN % INSTRUCCIÓN % load 30 jmpi 10 st 20 br 10 alu (sencilla+comp) 20,20+10 noop 0 g) Suponer ahora que el compilador ha insertado nops en los huecos de retardo y en todos los casos susceptibles de provocar riesgos por dependencias (load-uso, aritmética-salto condicional, aritmética compleja). Obtener la nueva distribución de instrucciones y calcular el valor de CPI. CPI = INSTRUCCIÓN % INSTRUCCIÓN % load jmpi st br alu (sencilla+comp) noop

4 a) Dibuja el grafo de dependencias del siguiente código: PROBLEMA 3 Estudio de un procesador con lanzamiento fuera de orden (30 puntos) ini ld r1, [r6] add r1, r1, r2 sub r1, r1, r3 st r1, 512[r6] add r6, #4, 16 sub r5, r5, 1 bnz ini b) Se ejecuta el código anterior con el procesador con lanzamiento fuera de orden visto en clase. Rellenar el diagrama temporal y obtener el CPI de la primera iteración. Pintar los cortocircuitos utilizados y especificar el renombre de registros (asignación y liberación) siguiendo la convención habitual del curso. Estado inicial: 1 ini: ld r1, [r6] 2 add r1, r1, r2 3 sub r1, r1, r3 4 st r1, 512[r6] 5 add r6, #4, 16 6 sub r5, r5, 1 7 ini: ld, r1, [r6] 8 <r1,p1>,<r1,p1>,<r1,p1>; resto de registros físicos disponibles B D B c) Codifica un 2-desenrollado del bucle planificando las instrucciones para minimizar riesgo de datos.

5 PROBLEMA 4 Prácticas (30 puntos) a) Práctica 1: Simulador de memoria cache (4 puntos) Señala sobre el siguiente esquema de de 32 bits que lanza el procesador, los 3 campos necesarios para la organización de la cache: marca (tag), conjunto (set) y byte dentro del bloque, en el caso de la cache unificada de 64 kb, mapeo directo y bloque de 32 B que has usado en la 1ª práctica b) Práctica 2: Análisis de organizaciones de memoria cahce (8 puntos) b.1) Calcula el número de ciclos que requiere un fallo de escritura que provoca el reemplazo de un bloque sucio (política copy-back con buffer de escrituras). b.2) Escribe la expresión que has utilizado para calcular el CPI en la segunda práctica. c) Práctica 3: Simulador de un procesador segmentado (8 puntos; contestar mal pruede restar hasta 8 puntos) Supón que el código de detección de riesgo y activación de los posibles cortocircuitos (i.e. incremento del correspondiente contador de uso) se ha encapsulado en una función cuentacortos. Abajo se muestran cuatro fragmentos de posibles codificaciones de la etapa de decodificación usando esa función. Escribe a continuación cuál de los fragmentos es el correcto [A, B, C ó D]: [A] if (etapa_ain.co==load && (etapa_ain.rd==etapa_ain.rs1 etapa_ain.rd==etapa_ain.rs2)){ [B] if (etapa_ain.co==load && (etapa_ain.rd==etapa_ain.rs1 etapa_ain.rd==etapa_ain.rs2)){ [C] if (etapa_ain.co==load && (etapa_ain.rd==etapa_ain.rs1 etapa_ain.rd==etapa_ain.rs2)){

6 [D] if (etapa_ain.co==load && (etapa_ain.rd==etapa_ain.rs1 etapa_ain.rd==etapa_ain.rs2)){ d) Práctica 4: Análisis de prestaciones (MIPS y MFLOPS) (10 puntos) Se ha obtenido este código SPARC para el bucle más interno for (j=0 )- de gauss.c:.l : ldd [%02], %f40 add %q3, 1, %95 add %02, 8, %02 ldd [%01], %f46 cmp %q5, %16 fmuld %f42, %f40, %f44 fsubd %f46, %f44, %f48 std %f48, [%01] add %01, 8, %01 bl,a, pt %icc,.l ldd [%q2], %f42 Al ejecutar gauss 32x en un procesador con frecuencia 1165 MHz, obtenemos la siguiente salida: xxxxxx Resultados xxxxxx Tiempo medio de ejecución de L/U: µseg Tiempo medio de ejecución limit: µseg Tiempo total de ejecución de repeat: µseg Suponiendo que el tiempo de ejecución se debe principalmente a la ejecución del bucle más interno (despreciamos el coste temporal de las instrucciones que implementan el bucle externo), qué velocidad en MIPS y MFLOPS se está alcanzando? Especifica fórmula y resultado. MIPS = MFLOPS = e) Asumiendo las mismas hipótesis del apartado anterior, cuál es el ancho de banda de memoria consumido por las instrucciones buscadas? Cuál es el ancho de banda para los datos de coma flotante (agregado de lecturas y escrituras)? Especifica las fórmulas utilizadas para calcular ambos resultados: BWi = BWd= f) Calcula el IPC del bucle: