1 / 83

Teo 2: Plataformas para programación paralela

Teo 2: Plataformas para programación paralela. Algoritmos paralelos Glen Rodríguez. Arquitectura tradicional de una computadora secuencial. CPU + RAM conectado por un bus Los 3 elementos pueden ser cuellos de botella Mejora: múltiples elementos. Arquitecturas secuenciales mejoradas.

giona
Télécharger la présentation

Teo 2: Plataformas para programación paralela

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Teo 2: Plataformas para programación paralela Algoritmos paralelos Glen Rodríguez

  2. Arquitectura tradicional de una computadora secuencial • CPU + RAM conectado por un bus • Los 3 elementos pueden ser cuellos de botella • Mejora: múltiples elementos

  3. Arquitecturas secuenciales mejoradas • Si la multiplicidad de elementos es ocultada al programador: paralelismo implícito. • Cuando se puede, se debe reescribir un programa para que aproveche al máximo el paralelismo implícito, antes de paralelizar “a mano”.

  4. La Control Unit coordina todo

  5. Registros • Mini memorias (chica, permanente) dentro de la CPU, usadas para ciertos propósitos especiales • Directamente manipuladas por la CU • Funcionalidad específica • Tamaño en bits o bytes (no MB como la memoria RAM, ni siquiera KB) • Guardan data, direcciones o instrucciones

  6. Registros • Uso • Acceso rápido para el programa que se está ejecutando en un momento dado • Guarda data necesitada de inmediato o repetidamente. • Guarda info sobre el estatus de la CPU y del programa corriendo • Dirección de la siguiente instrucción del programa • Señales de dispositivos externos • Registros de propósito general • Registros visibles al usurio • Guardan resultados intermedio o valores de datos. Ej: contadores de un loop • Varias docenas en CPUs actuales

  7. Registros de propósito especial • Program Count Register (PC) • Puntero a una instrucción • Instruction Register (IR) • Guarda la instrucción cargada desde memoria • Memory Address Register (MAR) • Memory Data Register (MDR) • Status Registers • Estatus de la CPU y del programa corriendo • Flags (variable booleana de 1 bit) que hacen seguimiento de condiciones como el carry y el overflow de operaciones aritméticas, errores de la computadora, etc.

  8. Operaciones en los registros • Guardan valores de otras localizaciones (registros y memoria) • Sumas y restas • Shift (desplazar) o rotar data • Contenidos de los tests condicionales básicos (if ?=0 else …; if ?>0 …)

  9. Operación en Memoria • Cada localización en memoria tiene una dirección única • La dirección de una instrucción se copia al MAR, el cuál ubica la localización en memoria • CPU determina si la operación es grabar o leer • Se realiza la transferencia entre el MDR y la memoria • MDR es un registro que se puede leer y escribir

  10. Relación entre MAR, MDR y la Memoria Data Dirección

  11. Ejemplo MAR-MDR

  12. Capacidad de memoria • Determinada por 2 factores 1. Número of bits en el MAR • 2K donde K = cantidad de bits en el registro MAR 2. Tamaño del parámetro “dirección” en las instrucciones • 4 bits permite 16 lugares de memoria • 8 bits permite 256 lugares • 32 bits permite 4,294,967,296 ó 4 GB • Importante para la performance • Memoria insuficiente puede causar que el procesador trabaje a menos de 50% de su performance de fábrica.

  13. Ciclo Fetch-Execute • Una instrucción no se puede ejecutar en un solo ciclo de reloj, por que tiene que cargar tanto las instrucciones como la data desde memoria. • Fetch (carga) • Decodificar o encontrar la instrucción, cargarla de memoria al registro y avisar a la ALU • Execute (ejecuta) • Ejecuta la operación según lo que dice la instrucción • Mueve/transforma data

  14. Ciclo Fetch/Execute –carga

  15. Ciclo Fetch/Execute –grabación

  16. Ciclo Fetch/Execute – sumar

  17. Instrucciones • Instrucción • Comando dado a la computadora • Hace que la señal eléctrica sea enviada por ciertos circuitos para ser procesada • “Instruction set” • Su diseño define las funciones soportadas por el procesador • Diferencia las arquitecturas de computadoras por: • Número de instrucciones • Complejidad de operaciones ejecutadas por una instrucción • Tipos de data soportados • Formato (layout, longitud fija vs. variable) • Uso de registros • Manejo de Direcciones (tamaño, modos)

  18. OPERANDO fuente OPERANDO resultado OPCODE Elementos de una instrucción • OPCODE: tarea o comando • OPERANDO(s) fuente • OPERANDO resultado • Ubicación de la data (registro, memoria) • Explícito: incluido en la instrucción • Implícito: se asume por default Direcciones

  19. Formato de instrucciones • Formato dependiente del CPU que define: • Longitud del OPCODE • Número de operandos • Longitud de los operandos Ej.: Formato de 32-bit

  20. Formato de instrucciones: CISC

  21. Formato de instrucciones: RISC

  22. Tipos de Instrucciones • Transferir data (cargar, guardar) • Más común, más flexible • Manipula memoria y registros • Definición de word (palabra)? 16? 32? 64 bits? • Aritméticas • Operadores + - / * ^ • Enteros y punto flotante • Logical or Boolean • Operadores relacionales: > < = • Operadores boolenaos AND, OR, XOR, NOR, y NOT • Operaciones de un solo operando • Negar, decremento, incremento

  23. Más tipos de instrucciones • De manipulación de bits • Flags para verificar condiciones • Shift (desplazar) y rotar • Control del programa (saltar) • Instrucciones de Stack • Operaciones en data múltiple • Control de I/O y de la máquina

  24. Paralelismo Implícito en las CPUs • Pipelines y ejecución superescalar: sobreponer (hacer a la vez) más de una fase del ciclo fetch-execute. • Idea similar a una linea de montaje fabril. • Ejemplo: el pentium 4 tenia un pipeline de 20 fases. • Predicción del “branch”

  25. A B C D Paralelismo en las instrucciones: pipelines • Ejemplo: lavandería comunal • Ana, Beto, Carla y David tienen cada uno una carga de ropa sucia para lavar, secar y planchar • Lavadora toma 30 minutes • Secadora: 40 minutes • Planchar: 20 minutes • Una sola lavadora, una sola secadora, una sola plancha

  26. A B C D Lavada secuencial 6 PM medianoche 7 8 9 11 10 Tiempo 30 40 20 30 40 20 30 40 20 30 40 20 O r d e n • Lavada secuencial toma 6 hours para 4 cargas

  27. 30 40 40 40 40 20 A B C D Lavada con pipelining 6 PM medianoche 7 8 9 11 10 Time O r d e n • Ahora toma 3 horas y media

  28. Pipelining • No se acelera el tiempo de ejecución de una sola tarea, sino del conjunto de tareas. • Esta limitada por la “instrucción” más lenta (en el ejemplo, la secadora) y su desbalance respecto a las otras • Muchas tareas se hacen a la vez, cada una en una instrucción diferente • Potencial de acelerar procesos depende del número de “pipes” (operaciones simultáneas posibles) • Aparte hay un costo en administrar el paso de una operación a otra. • Mejor RISC. Pero también CISC, ej: P4

  29. Reg Reg Reg Reg Reg Reg Reg Reg Ifetch Ifetch Ifetch Ifetch DMem DMem DMem DMem ALU ALU ALU ALU Ciclo 1 Ciclo 2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7 Pipelining en CPU RISC O R D E N I N S T R .

  30. Pipelining • En la vida real, cada paso no necesariamente es de 1 ciclo. Algunos son de 2 ciclos, y otros pueden demorarse 4 o 5 ciclos, dependiendo de la instrucción. • Problemas posibles: • Estructurales: el hardware no puede soportar ciertas operaciones simultáneas • De datos: una operación depende de los resultados de otra aún no efectuada. • De control o de branch. • Estos problemas disminuyen la mejora de performance, y crecen si hay más pipes.

  31. Velocidad de CPU versus velocidad de acceso a memoria • La memoria puede ser cuello de botella • Latencia: tiempo desde que el CPU pide un dato en memoria hasta que lo obtiene efectivamente. • Bandwidth: tasa a la que se puede leer la data (bits/s ó bytes/s) • Ej.: tengo una CPU de 1GHz (clock 1 ns) conectada a una RAM de 100 ns. Multiplique 2 vectores de 10 elementos c/u., que están en la RAM

  32. Processor-DRAM Memory Gap (latency) CPU 60%/año (2X/1.5 a) 1000 CPU “Ley de Moore” 100 Performance Gap entre CPU y memoria(crece 50% / año) Performance 10 DRAM 9%/aó (2X/10 a) DRAM 1 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 Tiempo

  33. Niveles de la jerarquía de memoria Mayor nivel Capacidad, Tiempo de acceso Costos Staging Unidad de transfer. Más rápido Registros CPU 100s Bytes <1s ns Registros prog./compilador 1-8 bytes Instr. Operandos Cache 10s-100s K Bytes 1-10 ns $10/ MByte Cache Control de cache 8-128 bytes Bloques Memoria Pcpal. MBytes 100ns- 300ns $1/ MByte Memoria S.O. 512-4K bytes Páginas Disco 10s GBytes, 10 ms (10,000,000 ns) $0.0031/ MByte Disco Usario Mbytes Archivos Más grande Cinta infinito sec-min $0.0014/ MByte Cinta Menor nivel

  34. Mejor latencia usando caches • En vez de leer de 2 en 2 los elementos de los vectores, los leo una sola vez y los guardo en el cache más cercano a la CPU • Conviene acceder a la memoria y computar en el orden que minimize las lecturas de RAM y aproveche mejor el cache. • Ejemplo: multiplicar 2 matrices

  35. Notas en almacenamiento de la matriz • Una matriz es un array 2-D de elementos, pero en la memoria todo es “1-D” • Convenciones para almacenamiento de matrices • por columna (tipo Fortran); A(i,j) en posición A + i + j*n • por fila (tipo C); A(i,j) en posición A + i*n + j • recursivo • Usaremos por columna Matriz por columna en memoria Por fila Por Columna 0 5 10 15 0 1 2 3 1 6 11 16 4 5 6 7 2 7 12 17 8 9 10 11 3 8 13 18 12 13 14 15 4 9 14 19 16 17 18 19 La fila azul en la matriz está guardada en las líneas rojas Cache lines Fuente: Larry Carter, UCSD

  36. Intensidad computacional: eficiencia de algor. Balance de máquina: eficiencia de máquina Modelo simple de memoria a usar • Asumir que hay solo 2 niveles de memoria, rápida y lenta • Toda la data está al inicio en la memoria lenta • m = número de elemento de memoria (words) movidos entre la memoria rápida y la lenta. • tm = tiempo por operación en memoria lenta • f = número de operaciones aritméticas • tf = tiempo por operación aritmética (memoria rápida) << tm • q = f / m número promedio de flops por acceso a memoria lenta • Tiempo mínimo= f* tf, si toda la data está en mem. rápida. • Tiempo real • f * tf + m * tm = f * tf * (1 + tm/tf * 1/q) • Mayor q es tpo. más cercano al mínimo f * tf • q  tm/tfnecesario para obtener al menos 50% de velocidad pico

  37. Multiplicando Matriz y vector {implementa y = y + A*x} for i = 1:n for j = 1:n y(i) = y(i) + A(i,j)*x(j) A(i,:) + = * y(i) y(i) x(:)

  38. Multiplicando Matriz y vector {read x(1:n) de memoria lenta en memoria rápida} {read y(1:n) de memoria lenta en memoria rápida} for i = 1:n {read fila i de A de memoria lenta en memoria rápida} for j = 1:n y(i) = y(i) + A(i,j)*x(j) {write y(1:n) de memoria rápida a memoria lenta} • m = número de ops. en memoria lenta = 3n + n2 • f = número de ops. aritméticas = 2n2 • q = f / m ~= 2 • Esta multiplicación esta limitada por la velocidad de la memoria lenta

  39. Multiplicación de matrices por método trivial {implementa C = C + A*B} for i = 1 to n for j = 1 to n for k = 1 to n C(i,j) = C(i,j) + A(i,k) * B(k,j) Algoritmo tiene 2*n3 = O(n3) Flops y opera en 3*n2 words de memoria q puede llegar hasta 2*n3 / 3*n2 = O(n) A(i,:) C(i,j) C(i,j) B(:,j) = + *

  40. Multiplicación de matrices por método trivial {implementa C = C + A*B} for i = 1 to n {read fila i de A en memoria rápida} for j = 1 to n {read C(i,j) en memoria rápida} {read columna j de B en memoria rápida} for k = 1 to n C(i,j) = C(i,j) + A(i,k) * B(k,j) {write C(i,j) a memoria lenta} A(i,:) C(i,j) C(i,j) B(:,j) = + *

  41. Multiplicación de matrices por método trivial Número de accesos a memoria lenta: m = n3 para leer cada columna de B n veces + n2 para leer cada fila de A una vez + 2n2 para leer y escribir cada elemento de C una vez = n3 + 3n2 Así, q = f / m = 2n3 / (n3 + 3n2) ~= 2 para n grande, no hay mejora respecto a mult. matriz por vector A(i,:) C(i,j) C(i,j) B(:,j) = + *

  42. Impacto del bandwidth • Para mejorarlo: Aumentar el tamaño del cache (cache line). • Ejemplo: que pasaria si deseo multiplicar dos vectores de tamaño 100 c/u. y en cada cache line solo entran 20 floats? Y si entran 200 floats?

  43. Una arquitectura paralela genérica P = procesador, M = memoria P P P P M M M M Interconnection Network Memoria • Físicamente, dónde está la memoria?

  44. Modelos de programación paralela • Control • Cómo se crea el paralelismo? • Qué orden hay entre operaciones? • Cómo los diferentes hilos de control se sincronizan? • Data • Qué data es privada y qué data se comparte? • Cómo se accede o comunica la data compartida en forma lógica? • Operaciones • Qué operaciones son atómicas (indivisibles)? • Costos • Cómo contabilizar los costos respectivos?

  45. Ejemplo sencillo Sea la suma : • Descomposición paralela: • Cada evaluación y cada suma parcial es una tarea. • Asignar n/p números a cada procesador (1 al p) • Cada uno computa independientemente sus resultados “privados” y la suma parcial. • Uno (o todos) recolectan las p sumas parciales y computa la suma global. Dos clases de data: • Compartida lógicamente • Los n números originales, la suma global. • Privada lógicamente • Las evaluaciones de las funciones. • Y las sumas parciales individuales?????

  46. i: 5 i: 8 i: 2 Modelo de prog. 1: Memoria compartida • Un programa es una colección de hilos de control. • Se pueden crear dinámicamente en algunos lenguajes. • Cada hilo tiene variables privadas, ej: variables del stack local. • También hay variables compartidas, ej: variables estáticas, de bloques comunes, del heap global. • Los hilos se comunican implícitamente escribiendo y leyendo variables compartidas. • Los hilos coordinan sincronizando en variables compartidas. Memoria compartida s s = ... y = ..s ... Memoria privada P1 Pn P0

  47. Sumando con memoria compartida static int s = 0; HILO 1 for i = 0, n/2-1 s = s + f(A[i]) HILO 2 for i = n/2, n-1 s = s + f(A[i]) • Problema: “race condition” en la variables s • Una “race condition” o carrera por la data ocurre cuando: • Dos procesadores (o 2 hilos) acceden a la misma variable, y por lo meno uno la escribe. • Los accesos son concurrentes (no sincronizados) así que podrían pasar simultáneamente.

  48. Sumando con memoria compartida static int s = 0; … (s = 27) HILO 1 …. computa f([A[i]) y put en reg0 reg1 = s reg1 = reg1 + reg0 s = reg1 … HILO 2 … computa f([A[i]) y put en reg0 reg1 = s reg1 = reg1 + reg0 s = reg1 … 7 9 27 27 34 36 34 36 • Sea s=27, f(A[i])=7 en Hilo 1, y f(A[i])=9 en Hilo 2 • Si el programa está bien, s debería ser 43 al final • Pero puede ser 43, 34, o 36 • Las operaciones atómicas son lecturas y escrituras • Ose ve un número u otro, no medio número • Las sumas se hacen en registros (privados generalmente)

  49. static lock lk; lock(lk); lock(lk); unlock(lk); unlock(lk); Sumando con memoria compartida (mejorado) static int s = 0; HILO 1 local_s1= 0 for i = 0, n/2-1 local_s1 = local_s1 + f(A[i]) s = s + local_s1 HILO 2 local_s2 = 0 for i = n/2, n-1 local_s2= local_s2 + f(A[i]) s = s +local_s2 • Como la suma es asociativa, se puede reordenar • La mayor parte de cómputo es en variables privadas • La frecuencia de uso de mem. compartida baja, lo que puede mejorar la velocidad. • Pero hay un “race condition” en el update de la v.compartida s • Se puede solucionar añadiendo locks o candados (sólo un hilo puede usar el lock a la vez; los otros deben esperar)

  50. Modelo de máquina 1a: Shared Memory • Todos los procesadores se conectan a una memoria compartida grande. • Nombre típioc: Symmetric Multiprocessors (SMPs) • SGI, Sun, HP, Intel, IBM (nodos del Millennium, SP) • Chips multicore (hacía donde vamos) • Difícil escalar a gran número de procesadores • <= 32 procesadores es típico • Ventaja: uniform memory access (UMA) • Costo: es más barato acceder data en cache que en memoria principal. P2 P1 Pn $ $ $ bus memoria

More Related