material

Arquitecturas Paralelas
Carlos Figueira
Última actualización: Diciembre 1996
Contents
1 Generalidades sobre Paralelismo
1.1 Aplicaciones del paralelismo . . . . . . . . . . . . . . . .
1.2 Supercomputación en Venezuela . . . . . . . . . . . . . .
1.3 Mecanismos paa lograr mayor desempeño a nivel de HW
1.4 Taxonomı́a sencilla de computadoras . . . . . . . . . . .
1.5 Observaciones sobre diseños de nuevas máquinas . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
4
5
5
5
2 Introducción
2.1 Desempeño: latencia y ancho de banda . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Ley de Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 ¿Cómo medimos el desempeño de un computador para poder compararlo con otro?
2.4 Programas para medir desempeño . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5 Otros errores y/o suposiciones incorrectas comunes en la medida de desempeño . .
2.6 Bibliografı́a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
7
8
9
10
11
3 Pipelining y máquinas vectoriales
3.1 Factores que limitan speedup ideal de un pipeline
3.2 Complicaciones adicionales en manejo de pipeline
3.3 Más velocidad aún . . . . . . . . . . . . . . . . .
3.4 Falacias . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
15
15
16
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Máquinas vectoriales
4.1 Arquitecturas vectoriales . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 ¿ Cómo guardar matrices en un banco de mem. intercaladas de forma
y por columna sea lo más rápido posible? . . . . . . . . . . . . . . . .
4.3 ¿Qué otros tipos de accesos se utilizan? . . . . . . . . . . . . . . . . .
4.4 Arquitecturas basadas en reg. vect . . . . . . . . . . . . . . . . . . . .
4.5 Mejoras a máquinas vect. . . . . . . . . . . . . . . . . . . . . . . . . .
4.6 Métricas adicionales para medir desempeño de maqs vect. . . . . . . .
4.7 Trampas y falacias . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . .
que el
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . . . . . . .
acceso por fila
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
5 Sub-sistema de memoria
5.1 Cache . . . . . . . . . . . . . . . . . . .
5.2 Organización de un cache . . . . . . . .
5.3 Polı́ticas a definir para manejo de cache
5.4 Problemas abiertos . . . . . . . . . . . .
5.5 Efecto de las fallas . . . . . . . . . . . .
5.6 Cache en arq. vectoriales . . . . . . . .
5.7 Polı́ticas de actualización de mem. ppal
5.8 Cache y E/S . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
17
17
18
18
19
19
20
21
22
22
22
23
23
23
23
24
24
6 CASO MAQUINA VECTORIAL: CRAY
6.1 CRAY Y-MP C90 . . . . . . . . . . . . . . . . . . . . . .
6.1.1 Generalidades . . . . . . . . . . . . . . . . . . . . .
6.1.2 Pipelining and segmentation . . . . . . . . . . . .
6.1.3 Sección de comunicación inter-procesadores (ICS) .
6.1.4 Sección de cómputo del CPU . . . . . . . . . . . .
6.2 Sección de control del CPU . . . . . . . . . . . . . . . . .
6.3 Procesamiento paralelo . . . . . . . . . . . . . . . . . . . .
6.3.1 Memoria . . . . . . . . . . . . . . . . . . . . . . . .
6.3.2 I/O . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4 Programación . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
26
26
26
26
26
26
27
27
27
27
28
7 Cray Y-MP E
28
7.1 Generalidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.1.1 Diferencias con C90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
8 CRAY-1
28
8.1 CRAY-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2 CRAY-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3 CRAY X-MP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
9 Introducción a MIMD
9.1 Definición y objetivos . . . . . .
9.2 Modelos de desempeño . . . . . .
9.3 Granularidad . . . . . . . . . . .
9.4 Conclusiones sobre el desempeño
9.5 Taxonomı́a de MIMD . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
30
30
30
31
31
32
10 Redes de Interconexión
10.0.1 Introducción . . . . . . . . . . . .
10.1 Buses . . . . . . . . . . . . . . . . . . . .
10.2 Conmutadores de barras cruzadas o x-bar
10.3 Redes Multi-etapas . . . . . . . . . . . . .
10.3.1 Red de Clos . . . . . . . . . . . . .
10.3.2 Red de Benes̆ . . . . . . . . . . . .
10.3.3 Redes Banyan . . . . . . . . . . . .
10.3.4 Desempeño y ancho de banda . . .
10.3.5 Conclusión redes multi-etapas . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
34
34
34
35
36
37
37
37
37
37
11 MIMD Memoria Compartida
11.1 Técnicas de sincronización .
11.1.1 Test and Set . . . .
11.1.2 Incr y decr. . . . . .
11.1.3 Compare and Swap .
11.1.4 Fetch and Add . . .
11.2 Barreras . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
38
38
38
39
39
39
40
12 MIMD Memoria Distribuida
12.1 La comunicación . . . . . .
12.2 Enrutamiento . . . . . . . .
12.3 Topologı́as fijas . . . . . . .
12.3.1 Topologı́as comunes
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
41
41
42
44
44
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13 MIMD: Esquemas Hı́bridos
13.1 Motivación . . . . . . . . . . . . . . . . . . . .
13.2 Implementación de coherencia dinámica . . . .
13.3 Sistemas basados en directorios . . . . . . . . .
13.3.1 Directorios centralizados vs distribuidos
13.4 Latencia en accesos remotos . . . . . . . . . . .
13.4.1 Modelos de consistencia relajados . . . .
13.4.2 Prefetching . . . . . . . . . . . . . . . .
13.4.3 Multithreading . . . . . . . . . . . . . .
13.5 Problemas de la asincronı́a . . . . . . . . . . . .
13.6 Soporte para Sistemas Operativos . . . . . . . .
13.7 Casos . . . . . . . . . . . . . . . . . . . . . . .
13.7.1 DASH . . . . . . . . . . . . . . . . . . .
13.7.2 Alewife . . . . . . . . . . . . . . . . . .
13.7.3 KSR-1 . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
46
46
47
48
48
49
49
49
50
50
50
51
51
51
52
14 Subsistema de Entrada/Salida:
14.1 Esquema tı́pico de dispositivos de E/S . .
14.1.1 Caracterización de la carga de E/S
14.2 Benchmarks en el mundo de E/S . . . . .
14.2.1 Aplicaciones . . . . . . . . . . . . .
14.2.2 Sintéticos . . . . . . . . . . . . . .
14.3 Discos . . . . . . . . . . . . . . . . . . . .
14.4 Arreglo o baterı́a de discos . . . . . . . . .
14.4.1 Niveles de RAID . . . . . . . . . .
14.4.2 Comparación de niveles de RAID .
14.5 Caso MIMD: iPSC/2 . . . . . . . . . . . .
14.6 Otros casos . . . . . . . . . . . . . . . . .
14.6.1 CM-2 . . . . . . . . . . . . . . . .
14.6.2 CRAY Y-MP C90 . . . . . . . . .
14.7 Misceláneas . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
53
53
53
55
55
56
56
56
56
57
57
57
57
57
58
15 Máquinas SIMD
15.1 Arreglos de Procesadores
15.2 Experiencias en SIMD . .
15.3 Caso: el CM-2 . . . . . .
15.3.1 Procesador . . . .
15.3.2 Comunicaciones . .
15.3.3 I/O . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
59
59
60
60
60
61
61
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
Generalidades sobre Paralelismo
archivo: general.tex
[1 clase]
Contenido
Aplicaciones del paralelismo — Grandes desafı́os — Supercomputación en Venezuela — Mecanismos para
lograr mayor desempeño a nivel de harware — Taxonomı́a elemental de computadores — Observaciones
sobre diseños de nuevas máquinas
1.1
Aplicaciones del paralelismo
¿ Qué pbs. se corren en para.?
¿ Cómo se mejora el desempeño en Supercomputadoras?
• Laboratorios virtuales ( 3er paradigma de ciencia, junto a exper. y teorı́a)
• Manufactura: robótica, control de sistemas, diseño de plantas
• Economı́a: modelos socio-económicos
• Medicina: Procesos bioquı́micos, diseño de medicamentos y fármacos, investigación genética, diseño de
prótesis y herramientas para colocarlas
• Quı́mica computacional: diseño de catalizadores, membrana, nuevos materiales
• Ingenierı́a
–
–
–
–
Diseño de automóviles (choques), aviones
Análisis de estructuras
Seguridad de plantas nucleares
Modelaje de redes de transmisión de electricidad
Grandes desafı́os en supercomputación.
1.2
Supercomputación en Venezuela
La industria petrolera
Algunas aplicaciones iniciales no eran de interés en Vzla, e.g.: licitaciones para pozos. Pero en cambio:
Exploración
• 2 millones de LOC en Geofı́sica,INTEVEP.
• Procesamiento de imágenes sı́smicas (2D vs. 3D) 3D influye en flujo de caja al recuperar grandes
volúmenes más rápido (es decir, primero el más grande, p.e.)
Recuperación Pozos estructurales vs. reactores termoquı́micos / Modelos de percolación (autámatas celulares) / Modelaje de yacimientos (grids heterogéneos) (30.000 lı́neas - black oil sim.) / Petroquı́mica
y derivados (quı́mica computacional).
Refinación El modelo SIMPAR (modelo de área) / Modelos son realmente lineales? Los ceros ...
Otras industrias CVG / Electricidad — Edelca (powergrid ...) / Banca (sist. dist. de alta disponibilidad.
Modelo de inversión y carteras de activos)
1.3
Mecanismos paa lograr mayor desempeño a nivel de HW
Varios procesadores:
Conexión ¿C?ómo conectarlos entre sı́?
Memoria Esquema de memoria compartida / Distribuı́da / Hı́brido
I/O ¿ Cómo se accesa ?
Multiplicidad de unidades funcionando en cada CPU
• varias ULAS
• varios sumadores, mult., etc., independientes (superscalar) => uso de marcadores (scoreboards) para
llevar cuenta de registros y unidades funcionales requeridas
• unidades “paralelas” (sumador par. en vez de bit-serial, comp. paralelo, etc) esto no lo veremos
• segmentación encauzada en CPU
Ciclos más cortos para instrucciones más frecuentes (RISC, también op. más comunes tienen long.
más corta)
Solapamiento de op. CPU y E/S (E/S ind.): Controladores de E/S. DMA
Uso de jerarquı́a de memoria Registros — Cache — Mem ppal — mem sec.
El CPU suele ser 1000 veces más rápido que mem ppal.
Problemas tı́picos de jerarquı́a
• Cómo tener la inf. requerida en CACHE
• Coherencia/actualización de CACHE y mem. ppal
1.4
Taxonomı́a sencilla de computadoras
Flynn: SISD, SIMD, MISD (?), MIMD (SM/DM). (Pb: Vectorial?)
En qué nos concentraremos durante el curso: Paralelismo peq., moderado y masivo
La Ley de Amdahl vs. paralelismo masivo: los resultados de Gustafson
1.5
Observaciones sobre diseños de nuevas máquinas
o ¿Cómo puede fracasar una máquina antes de salir?
Un nuevo diseño debe tomar en cuenta:
Funcionalidad requerida
• soporte SO: UNIX, tam. de mem, manejo de mem. virtual, cambio de contexto
• soporte lenguaje
• pto flotante
• someterse a estandares: pto flotante (IEEE,DEC,IBM), I/O bus (VME,SCSI,Futurebus), Redes
– Ethernet
Costo
Tiempo de diseño diseños complejos tardan más
Sobrevivir tendencias
• hardware: capa. de DRAM: multiplica por 4 c/ 3 años. Chips de 4MB
• de softw.: req. de memoria crece de 1.5 a 2 por año => bits de direccionamiento se consumen a
0.5 a 1 bit anual (razón de abandono de muchas arq.), mejoras de compiladores
• mejoras en áreas:
Supercomp. mejoran 19% por año
Mainframes 16%
Mini
20 %
Micro
26 %
Ejemplo planifica para una compañı́a y un fabricante le ofrece una nueva máquina que será 2x más rápida
que las máq. de hoy, pero que saldrá en 3 años.
Si es un micro, en 3 años la ind. tendrá 1.263 ≈ 2. Conclusión: no es ninguna ganga.
2
Introducción
archivo: int.tex
[2 clases aprox.]
Contenido
¿Qué es paralelismo? — ¿Por qué paralelismo? — Paralelismo vs. Sist. Distribuidos — Tipos de paralelismo (resp. al número de proc.) — Orientación del curso — Cursos paralelismo USB — Niveles de
aprovechamiento de máquinas paralelas
Desempeño: latencia y ancho de banda — Ley de Amdahl — Medidas de desempeño: MIPS, MFlops —
Falacias — Benchmarks — Bibliografı́a
Mejoras Para mayor motivación, incorporar info sobre limitación inherente del secuencial: lentitud de
evolución (curva de aumento del reloj de 25% por año, ley de Moore sobre avances de 60% anual en la
densidad de chips). Estudiar los artı́culos de Gordon Bell en ACM del 89 [Bel89] y del 92 [Bel92] sobre
futuro de la supercomputación, y [SC91] sobre arquitectura en general.
2.1
Desempeño: latencia y ancho de banda
Recordar objetivos:
• Maximizar desempeño en una máquina
• Decidir entre dos arquitecturas
• Diseño de arquitecturas de mayor desempeño
¿Qué es el desempeño (performance)?
• Visión del programador: tiempo de respuesta/tiempo de ejecución/latencia
• Visión de un director de centro: cantidad de trabajos por hora/throughput/ancho de banda (BW)
Ejemplo: ¿Cuáles de las siguientes mejoras se reflejan en la latencia, ancho de banda o ambos (resp. a
sist. monoprocesador)?
Reloj más rápido: Ambos
1 Procesador por tarea: sólo BW
Procesamiento en par. de programs cientı́ficos: Ambos
BW y latencia no son completamente indptes.. Por ejemplo, un PIPELINE a nivel de tareas mejora BW
pero no latencia. Generalmente empeora. Nos concentraremos en latencia.
2.2
Ley de Amdahl
Principio de diseño para mejorar desempeño: acelerar el caso común (operaciones más frec.) Para cuantificar
esto, usaremos la Ley de Amdahl (1966 o 67):
Speedup
=
T. de ejec. sin usar aceleramiento
T. de ejec. acelerado
Ejemplo 1 Que mejora se obtiene si incorporamos un mecanismo que permite correr 10 veces más rapidamente, pero sólo se puede usar la mitad del tiempo:
Speedup =
Ttotal
1
=
Ttotal
0.5 +
+ 2×10
Ttotal
2
0.5
10
≈ 1.8
Ejemplo 2 Se mejora velocida del CPU 5x sin afectar tiempo de I/O, pero cuesta 5x. El CPU se usa
sólo 50% del tiempo (el resto espera por I/O). El costo del CPU es 30% del costo del sistema. Basado en
costo/beneficio ¿vale la pena la mejora?
Speedup= 0.5+1 0.5 =1.67
5
Costo nueva maq.=( 31 × 5) + 23 =2.33 × Costo vieja maq.
El costo aumenta más rapidamente que el speedup: no vale la pena!
2.3
¿Cómo medimos el desempeño de un computador para poder compararlo
con otro?
Preguntar
MIPS
pico: poco representativo. Toma la más rápida!
sostenido: en qué programa?
Contraejemplo: RISC vs. CISC. Se pierde la noción de tiempo total de ejecución.
Ejemplo de falacia del MIPS: Supongamos una arq. load/store, cuya mezcla de instr. en una carga
representativa viene dada por:
Instr.
Frecuencia No. de ciclos que tarda
Load
20%
2
Opr. ULA
40%
1
Store
12%
2
Branch
28%
2
Se construye un compilador optimizante que logra reducir las inst. ULA en 50%. Con un reloj de 20 ns.,
compare los MIPS del código no optimizado con los del optimizado.
El tiempo que tarda una instrucción promedio en ciclos por reloj (CPI) es
X
CP I =
f reci × ciclos/instri
i:Instruc
M IP S
=
ciclos/seg
CP I × 106
50M Hz
M IP Sviejo = (0.2∗2+0.4∗1+0.12∗2+0.28∗2)∗10
=50/16=31.25
6
50M Hz
M IP Snuevo = (2/8∗2+2/8∗1+1.2/8∗2+2.8/8∗2)∗106 =50/16=28.57
La compilación optimizante empeora el desempeño ? Dónde está el error?
Resp: El nuevo ejecuta menos instrucciones.
El tiempo CPU viejo es (No. Inst viejo)/(MIPS viejo 106 ) = 32 (No. Inst viejo) ns El tiempo CPU nuevo
es (0.8)(No. Inst viejo)/(MIPS nuevo 106 ) = 28 (No. Inst viejo) ns
Los fabricantes suelen publicar los MIPS de la siguiente manera:
• MIPS sin derivación Meaningless Indicator of Processor Speed.
• MIPS nativo (como el calculado antes): es necesrio completar con el nombre del programa usado, del
# de instr. ensamblador por # de instr. lenguaje “standard” (e.g. C).
• MIPS pico
• MIPS relativo, por ejemplo, VAX MIPS, relativo a la VAX 11/780. Para que tenga sentido habrı́a que
especificar con qué programa se hizo la medición, qué versiones de compilador y sistema, etc.
MFlops = (# de flops en un programa)/(Tiempo de ejecución * 106 )
Mide operaciones flotantes, no instrucciones . Intenta independizarse del problema del # de ciclos
por instrucción. Solo tiene sentido para programas instensivos en cálculo pto. flotante, sino absurdo (ej:
compiladores).
Inconvenientes:
√
• Diverso set de operaciones. CRAY-2 no tiene div, mientras que 68882 tiene div y .
• Heterogeneidad en tiempo de ejecución, por ejemplo, entre + y *. Una solución propuesta es normalizarlas (Normalized vs. native MFlops).
Peso propuesto
ADD,SUB,COMPARE,MULT
1
√
DIVIDE,
4
EXP,SIN
8
Ej: DEC 3100 corriendo SPICE. Nativo = 1.2 / Normalized = 1.7
Conclusión:
usar?
2.4
la medición de desempeño depende del programa ejecutado. La pregunta es qué programa
Programas para medir desempeño
Mi carga promedio (my program mix): es lo ideal pero es poco realista, puesto que:
• ¿cómo (y quién) corre el programa en todas las máqs disponibles?
• ¿quién entona el programa? ¿cuánto se entona?
Programa real representativo
que cumpla con las siguientes caracterı́sticas:
• Escrito en lenguaje de alto nivel (portable)
• Representativo de algún estilo de prog. o carga (eg: prog. numérica)
• medición es fácil
• amplia distribución
Propuestos a nivel de supercomputación por un grupo de universidades y compañı́as: Perfect Club. Es
un conjunto abierto de programas/algoritmos.
A nivel general: SPEC (Systems Performance Evaluation Cooperative Effort), propuesto por un grupo
que incluye practicamente todas las compañı́as importantes (IBM,ATT, SUN, DEC, etc). SPEC es un
conjunto de 10 programas de amplia difusión: GNU C, Circuit simulator, Monte Carlo sim., LISP interpreter,
Numerical kernels, etc.
Kernels: Son pequeños pedazos de programas muy utilizados que han sido extraı́dos para medir desempeño. Ejemplos son los “Livermore Loops” (24 lazos internos de comp. num. en fı́sica) y “Linpack”.
Linpack es un paquete de programas para álgebra lineal, el cuál suele utilizar BLAS (Basic Linear
Algebra Subrotines). Las subrutinas de BLAS operan sobre arreglos unidimensionales y están escritas
en ensamblador1 de cada máquina para max. perf. Existen varias versiones: simple y doble precisión,
rolled/unrolled loops (para maq. vect. rolled es mejor!).
Los inconvenientes de LINPACK son: no tiene div, no usa func. mat (sin,cos, etc), casi todo el tiempo
en una función (saxpy)2 , y baja localidad de datos.
Tpoy benchmarks No son nada representativos! Ej: criba de Erastótenes, Puzzle, Quicksort. Además
adolecen de una serie de fallas:
• 33% inst. ejecutadas son asig. de const.
• 5% asig. con result. de una expr.
• no hay “while”
• 50% son eval. control de lazos
• Solo trabaja enteros
• 58% variables son locales
• Son tan pequeños que la rata de hit de datso/inst es practicamente 100%.
Sintéticos: Tratan de combinar en un programa una mezcla de instrucciones que se considera “representativa”. Ej: Whetstones (en 1976-Algol 60, hoy en FORTRAN y PASCAL), tomado por estadı́sticas en un
centro de cómputo. Peculiaridades: alto porc. de flotantes, 50% del tiempo ejecuta librerı́as mat., pocas
variables locales (si se asignan var. glob a reg.— lo cual es muy raro —, el perf explota), alta local. de inst.
Otro ejemplo: Dhrystones. Condsidera explic. pbs de loclaidad, caece de operacioens flotantes, hasta
40% en func. sobre strings, si se usa versión anterior a 2.1, un eliminador de “dead code” puede descartar
hasta 25%!
2.5
Otros errores y/o suposiciones incorrectas comunes en la medida de desempeño
• Afirmaciones tales como: tamaño igual velocidad, velocidad del reloj.
• CPI puede calcularse de la mezcla de inst. y los tiempos de ejecución del mismo (e.g.: no toma en
cuenta jerarquı́a de memoria, ineficiencia de pipeline)
• Desempeño pico: solo garantiza la velocidad que nunca se superará. Ejemplo:
CRAY X-MP Hitachi
Mejor caso
2.6 sec
1.3 sec Hitachi 105% más rapido
FFT vect.
3.9 sec
7.7 sec CRAY 97
• ¿Qué se puede concluir entre dos maq. que se superan mutuamente en problemas diferentes?
1 Si
no existe en versión ensamblador sino FORTRAN, la perdida de desempeño puede ser hasta de 50%.
pequeño cache tendrá una alta rata de hits.
2 Un
2.6
Bibliografı́a
• [HB84] es un libro general, aunque un poco viejo. Los principios expuestos siguen siendo válidos,
aunque los ejemplos citados son de máquinas por lo general obsoletas. La parte multi-procesadores es
muy pobre.
• [AG89] trata de cubrir las áreas de principios y generalidades del procesamiento paralelo (”Foundations”), la parte de software y finalmente la de arquitectura. No entra en profundidad en ninguna de
ellas pero dá una visión general del área. No cubre vectoriales. En arquitecturas es un compendio de
máquinas paralelas.
• [PH90] es utilizado esencialmente en sus capı́tulos relativos al desempeño, vector processors, pipelining,
memory hierarchy y I/O. No trata las arquitecturas MIMD.
• [Sto90] es otra referencia. Analiza en profundidad el sub-sistema de memoria.
• Revistas especializadas: IEEE Computer, CACM, IEEE T. on P and D Syst, SIGCA, J. of Par and
Dist. Comp, I. Journal on Supercomputing. En particular artı́culos como [Bel89, Bel92], [SC91] y
otros tantos en benchmarking [Wei90], números especiales como [ACM92], etc.
3
Pipelining y máquinas vectoriales
archivo: pipeline.tex
[2 clases]
Fundamento Incremento de velocidad por etapa del cauce.
Sea un pipeline de k etapas (de igual duración)
Speedupn =
Tseq
nk
Tk = k+(n−1)
El término k en el denominador es el tiempo que tarda en llenar el pipe. Notese que cuando n k y
n → ∞ =⇒Speedup → k
Es decir, a mayor etapas, “más paralelismo”, i.e. mayor throughput de instrucciones
Qué podemos encauzar para mejorar velocidad de ejecución?
En 1 procesador
• El ciclo de instrucciones
• Operaciones aritméticas: hasta 14 etapas en CRAY-1 . hasta 26 en CYBER 205
• Operaciones vectoriales
En sistema de procesadores MIMD (organizado por SW) y Arq. Sistólicas
3.1
Factores que limitan speedup ideal de un pipeline
Propagación de reloj a todas las etapas:
Acceso de memoria:
En la tecnologı́a actual esto limita a entre 10 y 20 etapas.
Sea una máquina RISC sencilla, LOAD/STORE, una instrucción por palabra
1. Inst. Fetch – prefetch
2. Dec – decode y operand register fetch
3. Exec – ejecución y cálculo de dire.
4. MEM – accesar operandos en memoria (sólo si instr. LOADS/STORES)
5. WB – guardar resultados en registro
Instr.
Instr.
Instr.
Instr.
1
2
3
4
IF
Dec
Exe
Mem
WB
|-AM--|-----|-----|-AM--|-----|
|-AM--|-----|-----|-AM--|-----|
|-AM--|-----|-----|-AM--|-----|
|-AM--|-----|-----|-AM--|-----|
La memoria debe tener capacidad de ejecutar 2 accesos por ciclo.
Soluciones:
• Uso de cache (depende de una buena localidad)
• Separación de cache de instr. y datos
• Requerimientos de lograr pipeline de accesos (por ejemplo, que pasa si hay falla en cache?)
=⇒ el potencial cuello de botella es movido al subsistema de memoria
Azares estructurales (Structural Hazards)
En la multiplicación de punto flot. hay operaciones sobre la ULA que son costosas, p.e, el shift: es
preferible varias etapas shift de un ciclo a 1 completa de k ciclos. Una multiplicación flotante está dividida
en varias operaciones: suma de los exponentes; generación de los productos parciales de las mantisas (multiplicación); suma de los productos parciales; redondeo al numero de bits según la precesisión; renormalizar
el resultado.
Sumar expon.
Multip. manti
Sumar. prod. parc.
Renormalizar
Redondear
t=1
X
2
3
4
X
X
X
X
5
6
X
7
X
X
Pero si vienen dos sumas seguidas X y Y, se produce un conflicto de uso
Sumar expon.
Multip. mant.
Sumar. prod..
Renormalizar
Redondear
t=1
X
2
Y
X
3
4
XY
X
Y
XY
5
Y
X
6
7
Y
X
X
Y
=⇒ Introducir retardos (burbujas, pausas) para evitar conflictos estructurales. Otra técnica es la greedy
que lanza una operación al momento que no haya conflicto. La técnica basada en vectores de colisión (que
dá resultados buenos), que permiten
• Determinar en c/ paso si el comenzar otra operación conducirı́a a un conflicto posterior
• Determinar el ciclo de comienzo de instr. que maximiza el thruput de instr. (ver Hwang y Briggs,
Stone, etc. para más detalles). Por ejemplo, es posible que una retardo mayor induzca un mejor
desempeño.
Elóptimo se obtiene introduciendo retardos entre etapas de manera apropiada.
Esta técnica nos permite que, dada una situación potencial de aparición de colisiones, como obtener el
máximo desempeño en tales condiciones. Sin embargo, el mayor desempeño se logra si logramos evitar tales
colisiones, por ejemplo:
• Replicando elementos/recursos crı́ticos del HW
• Cambiando el orden de operaciones. Ej: no permitir dos sumas seguidas suma→suma →load =⇒suma→load
→suma. Esto es generalmente responsabilidad del compilador optimizante.
Dependencias (Azares de datos)
Una dependencia de datos puede producir también burbujas. Ej:
ADD R1,R2,R3
(R1 ←− R1+R3)
SUB R4,R1,R5
(R4 ←− R1 – R5)
ADD
SUB
t=1
2
3
4
5
._______._______._______._______._______.
Fetch
Dec
R2+R3
[Mem]
R1 <._______._______._______._______._______.
Fetch
Dec
R1-R5
[Mem]
R4 <-
En t=4, el nuevo valor de R1 por el ADD aún no ha sido actualizado, por lo que el valor usado en SUB
es erróneo.
Solución: forwarding o bypassing. El resultado de la ULA siempre es realimentado al latch de entrada
de la ULA. El HW detecta si la entrada de la próxima instr. debe ser tomada del latch o de los registros.
Inconv. Implementación de bypasses tiene su costo en HW.
Otra solución es mediante reordenamiento de código (trabajo del compilador)
Ej: A ←−B + C
LD R1,B
.Fetch
.Dec
.Ej
.←B
.R1 ← .
LD R2,C
.
.Fetch
.Dec
.Ej
.←C
.R2 ← .
ADD R3,R1,R2.
.Fetch
.Dec
.burb.
.R1+R2 .mem
.R3 ← .
ST R3,A
.
.
.Fetch
.burb.
.Dec
.Ej
.
.
Podrı́a enviarse directamente el resultado del add a memoria sin pasar por R3.
En general, la reexpedición interna busca evitar accesos a memoria innecesarios:
1. R1 −→Mx −→R2 =⇒R1 −→
.
• −→Mx
• −→R2
2. Mx −→R1 Mx −→R1 =⇒Mx −→R1 −→R2
3. R1 −→Mx R2 −→Mx =⇒R2 −→Mx
También el compilador podrı́a tratar de evitar LD seguido por instrucciones que usan inmediatamente el
valor.
Ej: Supongamos que 20% de instr. son LD y 50% de las veces al LD le sigue una instr. que requiere el
res. de la carga. Si la burbuja es de 1 ciclo ¿Cuánta velocidad se pierde?
3
0.8 × 1 + 4 0.2 × 1.5 = 1.1=⇒10%de retraso
Si no hay orden posible que arregle el pb, introducir nop, ie, burbuja, lo cual es más barato que HW
especial.
(en vectoriales veremos otra solución a este problema a nivel de la algoritmica, p.e.: cyclic reduction)
Otros azares de datos se producen en los accesos a la memoria. Estos, por la inyterdependencia, pueden
también producir burbujas en el pipe:
RAW : Leer después de escribir puede traer interlock ya que puede no estar actualizada la memoria cuando
empieza la lectura.
WAR : si la lectura no ha terminado y se manda a escribir hay carrera critica
WAW : carrera crı́tica
RAR : No trae problemas.
Bifurcaciones (Azares de control)
Problema: la próxima inst. buscada, puede no ser la próxima a no ser ejecutada. Ej:
ADD R1,R2,R3
BZ
R1, α
...
α : ...
Hwang and Briggs citan que pipelining puede perder 30-40% efectividad por pbs. de bifurcación
Soluciones: Delayed Branching / Bifurcaciones pronosticadas / Historia de bifurcaciones
3 80%
4 20%
de las veces no hay pb.
de las veces son LD, de las cuales 50promedio para una carga
Delayed Branching: Cambiar orden de instrucciones.Ej:
ADD R1,R2,R3
BZ
R4, α
...
α : ...
se cambia a
BZ
R1, α
ADD R1,R2,R3
...
α : ...
eg: RS6000, basado en observaciones que rara vez se salta sobre una condición recién calculada(!)
Pronosticar la bifurcación a tomar (adivinar camino a tomar): Si salto hacia atrás (fácil de reconocer
por offset negativo), pronosticar hacia atrás =⇒probablemente sea un lazo, los cuales generalmente se ejecutan más de una vez.
BZ — suponer que no da cero
Esta estrategia da resultado en parte porque la inst. a buscar debe estar en el cache (en general). También
por el uso de res. temp. — no se obliga a escribir el resultado hasta que se sepa a ciencia cierta que el
pronóstico es valedero
Historia de bifurcaciones En BP y BN (igualmente probable; depende del compilador) ¿ Hacia donde
salto? podrı́a dejarme convencer por frec. hist. previa a corto plazo. Como los caches se adaptan bien al
comportamoento en hist. reciente, podemos tomar las ideas
Inst. addr
|
|---->
Branch ad.
aaa
bbb
...
Target addres
yyy
xxx
...
Si la instrucción está en el cache, se toma el valor (último utilizado) y se actualiza luego de ejecutada con
el valor real (no el predicho). Si no está, incorporarla al cache con la dirección de branch tomada (polı́tica
de reemplazo?)
Esta idea aún no ha sido muy usada en la práctica (solo IBM 3090 mode. 400, 1986) pero suena razonable
dados las caract/costos de HW actuales (ver Stone p. 175).
H y B sugieren manejo de 2 mem. cache: una por alternativa de salto =⇒engorroso!
3.2
Complicaciones adicionales en manejo de pipeline
Manejo preciso de interrupciones según standard IEEE En realidad, la secuencia ADD SUB de la
pag. 13 puede conducir a carrera crı́tica si ocurre interrupción a mediados de ejecución. Al cambiar orden
de ejecución ADD −→DIV por DIV −→ADD, y ambas producen trap, ¿Cuál se trabaja primero? ¿Por qué?
Para trabajar correctamente el VAX 8800 requiere 4 PC: Program counter, Current Program Counter, IBox
Starting Address, EBox Starting Address5
Aparte, encolar resultados: adelantar los pipes hasta que se puede usar (history file y future file)
Heterogeneidad en duración de inst.: En la Vax una inst. puede llevar de 1 a 100s ciclos =⇒ventajas
de RISC (aunque VAX 8800 lo que hace es pipeline the micro-engine!!)
3.3
Más velocidad aún
Introducir delays para alargar # de etapas: Si suma tarda 3 ciclos, convertirlo en 3 etapas de 1 ciclo
=⇒Cada inst. tarda más pero completamos en cada instr. (ver Stone)
5 Sirven
para saber para cada instrucción donde está en proceso pipeline, 1 PC por etapa!
Loop Unrolling
Máquinas superescalares Ejecutan más de una instr. a la vez, eg: una de pto flot. y una entero. El
manejo de interrupciones requiere aún más cuidado. Ej:
• en SPARC, instr. enteras no causan pb porque terminan pero op. flot. se limitan a 2, y aún ası́, son
imprecisas
• dejar entrar al ALU una instr. solo si las que ya están en ALU no pueden causar interrup. (no es muy
razonable por costo para cosas poco frecuentes)
Encadenar pipelines * seguido de +. (ver máq. vectoriales)
3.4
Falacias
El diseño del set de instr. de las m. es indep. de supipelining:
No, por complicaciones de
• Instrucciones de tamaño variable =⇒Imbalance en etapas, retardos y complican detección de azares.
• Modelos de direcc. sofisticados (post-incr, multiple acceso a mem)
Incrementar el # de etapas del pipe siempre incr. desempeño No, por pbs técnicos de reloj. No,
por mayor dependencia de lazos. Ej: en 14 Livermore Loops (agregar gráfica)
Evaluar un esquema de pipeline con código no-optimizado El código optimizado es más difı́cil de
alterar o reordenar para pipeline. Algunos autores encuentran que ene lc ódigo optim. hay 20% menos
thruput.
4
Máquinas vectoriales
archivo: vector.tex
2 clases
Definición Una máquina vectorial es aquella que tiene instrucciones especiales para trabajar sobre vectores, e.g.
C := A + B
implementados de manera de obtener un alto rendimiento.
Propiedades importantes de tener operaciones vectoriales
• Al pedir una instrucción vectorial se garantiza la ausencia de azares por datos (Ojo! no todo lazo sobre
elemento de un vector garantiza esta independencia =⇒ no todo lazo puede ser vectorizado)
• Una única instrucción vectorial cvonlleva mucho trabajo =⇒red. req. de BW respecto a instr. Pueden
encontrarse reduciones de 600 a 1, ej, SAXPY. Esto rompe con la homogeneidad de duración del set
deinst.
• Las instr. vect. tienen un patrón de acceso predecible:
C[1: 7 : 2]
inf :sup:stride6
:= A[2 : 5 : 1] + B[7 : 4 : −1]
Si es predecible, tal vez podamos incorporar mecanismos para suplir suficientes datos al pipe vect. en
el tiempo requerido
• Se eliminan los azares de control (no hay bifurcación)
¿Cuántas ints. vect? Entre 20 y > 100. La IBM 3090 VF tiene 171
4.1
Arquitecturas vectoriales
Si requerimos hacer operaciones como C := A+B logrando (después de start-up time)una operación completada por ciclo, la memoria requiere trabajar a una velocidad de 3 accesos por ciclo −→PROBLEMA CLAVE!
Soluciones:
• Una memoria de alta velocidad (tipo cache) y sacar datos vectoriales de allı́ (pb: tamaño)
• Memorias intercaladas: dos formas de acceso
– Accesadas de manera sı́ncrona, capturadas en latchs para luego transferirlas una por una.
– Accesadas de manera defasada(en pipe)
El número depende de los req. de la unidad de pipe y de la latencia de la memoria.
Ejemplo: Un pipe que requiere tres accesos por ciclo. La mem. tiene una latencia de 2 ciclos
=⇒3 × 2⇒6 módulos de mem (en general, son potencias de 2)
Ejemplo El siguiente ej. muestra una situación ideal para el proc. vectorial. Tenemos un banco de 8
módulos de mem. con dos ciclos de latencia, y un sumador en pipe. de 4 etapas. La operación realizada es
X = A + B.(llevar p. 264 del Stone).
En este caso, se obtiene un BW de un res. por ciclo. Los pbs surgen cuando los elementos no pueden
almacenarse de manera ótima. Ej:
A
C
:= (E + F ) + G
:= A + B
Las instr. anteriores pueden requerir otro patrón de almacenamientos que produzcan conflictos. Conflictos
en acceso matan una máqina vectorial Posible solución: introducir retardos (CDC Star). Ej: todos
los vectores empiezan en M0 . Se accesa primero A[0] y se guarda en un buffer durante dos ciclos (mientras
se accesa B[0]). Se obtiene el mismo BW pero aumenta la latencia (en vez de empezar a obtener res. al 5
ciclo, lo hace al cabo de 11)
Aunque la solución es elegante, su abuso conduce a desempeño muy inferior a lo lograble mediante otras
arq., eg CRAY-1 vs. CDC Star.
Trampa Concentrarse en desempeño pico e ignorar startup time. Este determina el tamaño de los vectores
para el cuál se obtiene un desempeño mejor que escalar. Esta métrica se denomina nv . Para CDC-Star 100
es 100 y para CRAY-1 es 2. Para que Cyber 205 (descendiente de STar) sea mejor que CRAY-1 se necesitan
vectores de al menos 200 para SAXPY.
Hay algoritmos muy usados, como eliminación gaussiana (para triangular matrices) que en cada iteración
se decrementa de uno la longitud del vector. Otras caracterı́sticas de este algoritmo (comunes a otros algo.
numéricos) son:
• Requiere accesos por filas y por columnas de una matriz
• Operaciones son, en su mayorı́a, V × V →V , V × escalar→V
• Excepciones son operaciones de reducción (escalares) como MAX, que devuelve la posición del elemento
mayor. Este será el pivote.
4.2
¿ Cómo guardar matrices en un banco de mem. intercaladas de forma que
el acceso por fila y por columna sea lo más rápido posible?
[fotocopiar Stone 280+282]
En matriz 8x8 con 8 módulos, almacenar por filas será terrible para acceso por columnas, ya que todos
los ele. de una col. estarán en el mismo módulo. Es preferible agregar una columna dummy.: stride para
acceso por fila: 1, para col:9.
Una forma de evitar este problema es seleccionar un paso7 “s” (es decir, una forma de guardar los elemntos
en mem) que sea primo relativo al núemro de módulos. Los pasos sucesivos accesan módulos separados de
M/MCD(M,s). Como M es generalmente potencia de 2, cualqier s impar salva la situación
4.3
¿Qué otros tipos de accesos se utilizan?
Según Kuck, además de por filas y por col., tenemos:
• por diagonales/antidiagonales. No es posible accesar eficientemente por filas, columnas y diagonales si
el # de módulos es potencia de 2.
• Bloques cuadrados.
Dos sugerencias:
• Que el númeor de módulos en 1 banco no sea una potencia de 2 sino un número primo. (Ej: BSP, con
17, o GF11, con 567?)
• Aplicando hashing a las posiciones de los elementos (no implementado). Es un temas importante de
investigación (Ej: Supercomputing 92: Lang, Valero et al., “Acceso en potencias de 2 sin conflicto”).
Hay otros accesos, s=2, etc. En conclusión: el porgramador debe cuidar/estar pendiente de asignación
de elem. de matriz a memoria según sus patrones de refe.
7 stride
4.4
Arquitecturas basadas en reg. vect
• CRAY intercala bancos de registros vetcoriales entre mem. ppal y pipe vect.
• No es raro encontrar bancos de 64 o 128 reg.
• A diferencia de un cache, deben manejarse explicitamente (compilador o programador)
• A veces puede utilizarse otra mem. entre ppal y reg, que permitira reestructurar datos (ej: para accesar
col. en vez de filas, p. 286b Stone). La ventaja sobre otros métodos (hashing, realignement network)
es que sólo se hace cuando se necesita.
• Los vectores de largo variable (VLR) traen inconv. =⇒técnica de strip-mining
• Soporte del compilador, por ejemplo, para lazos internos: dep. entre elem, intercambiar lazos, strip
mining (ver prox. curso)
Strip-mining: Los registros vectoriales tienen un tamaño que determina el número máximo de elementos
que puede procesarse simultáneamente de manera vectorial. Este es el Maximum Vector Length (MVL). El
tamaño de una operación vectorial es un parámetro dinámico, por lo que se usa un registro especial, VLR,
para guardar dicha talla. Strip-mining es la generación de código tal que cada operación vectorial sea hecha
para una talla ≤ MVL.
Si el número de elementos a procesar es N > M V L, la operación debe realizarse en varios bloques. El
primero se hace por el resto de la división entera por MVL, es decir, V LR←N mod M V L, y el resto de
las operaciones se harán tal que V LR←M V L. Esto implica un overhead adicional de load y store de los
bloques, y de carga del nuevo valor de VLR.
Ejemplo: la version strip-mined de SAXPY es (tomado de H y P,p. 364)
low = 1
VL = (N mod MVL) /* bloque incompleto */
do 1 j = 0,(N/MVL) /*lazo externo*/
do 10 i = low,low+VL-1 /* vectorizado por el compilador */
Y(i) = a*X(i) + Y(i)
10:
continue
low = low + VL /* inicio del nuevo vector */
VL = MVL /*resetea MVL */
1: continue
Conduce al siguiente modelo de desempeño
Ttotal
= TstartupT otal a + (
N
+ 1) × (Tlazo b + (Tstartup c ) + N × Telem
MV L
a Cáclulo
de la dirección del vector, inicialización control vectorial, etc
escalar de stripmining
c recarga de pipes por bloque
b código
4.5
Mejoras a máquinas vect.
Encadenamiento (forwarding extendido a unidades vectoriales): Ejemplo: SAXPY
Comparación interesante respecto a capa. de encadenamiento en Cheng “Vector Pipelining, Chaining
and Speed on the IBM 3090 and CRAY X-MP”, Computer, Sept. 1989
• nV depende de operación (asig., SAXPY, etc)
– IBM: 5 – 13
– X-MP: 2
• X-MP es más robusto: tarda idem A*X+Y que (A+X)*Y. IBM es asimétrico
• División: IBM:17.4 ciclos. CRAY: 2 ciclos
• En X-MP: 14 ciclos para cargar un escalar, 17 para u elem. de vector.
Máscara de vectores (vectores enmascarados)
do 100 i=1,64
if A[i] <> 0 then A[i]:=A[i]-B[i]
100 continue
Las desventajas son: no reduce tiempo de eje.; En algunas máquinas, las oper. se ejecutan pero no se guarda
el res. =⇒interrup. por div por 0 puede ocurrir!
Oper. de reducción
s := ai × bi + s −→
si := si−d + ai × bi
Se termina con d sumatorias parciales que hay que sumar, y puede cambiar el orden de las sumas (overflows!).
Otra técnica es el “Recursive doubling”: se suman 2 vectores de 64 reg, luego 2 de 32 y asi ...
Manejo de matrices sparse
• Vector de bits: reducción 1 a 64. Se usa 1 bit para repr. 64 bits de una doble palabra. El problema es
que la esparsidad práctica es mucho mayor, e.g., SIMPAR: entre 0.1 y 0,01%
• Hashing non zero elem.
• Compresión/expansión: expandir esparse en vectores; hacer oper; recomprimir.
• Usar scatter/gather.(scatter: comprimir un vector de acuerdo a un vector máscara; gather: intercalar
dos vectores comprimidos)
Uso de varios pipes : igual que Tomasulo, etc. Bin-packing (método de scheduling)
Problema abierto
4.6
El uso apropiado de cache en sist. vect.
Métricas adicionales para medir desempeño de maqs vect.
Hockney’s
• r∞ : MFLOPS sobre vector infinito, i.e., se ignora el startup time. Generalmente n=1000.
−1
r∞
= lim
n→∞
Tstart + Te × n
⇒r∞ = 1/Te
n
• n1/2 : largo del vector para alcanzar r∞ /2. n1/2 = tstart /te ya que n1/2 se alcanza cuando el tiempo
de procesar esos elementos es igual al tiempo de startup.
Si mejoro el reloj, afecto r∞ mientras que si agrego etapas al pipe, afecto n1/2 .
Derivación de Hockney’s
Puede realizarse a partir de datos del fabricante: r∞ es ciclos por seg, si en cada ciclo puede darse una salida
(notese que depende de oper!).
n1/2 = s + k − 1, donde s es el overhead general (fetch operand, store VLR, etc.),k número de etpas de pipe.
También puede medirse experimentalmente: correr el sgte programa
call second(t1)
call second(t1)
To <- T2-T1
do 20 n=1,NMAX **1000
call second(t1)
do 10 i=1,N
10: A(I)=B(I)xC(I)
call second(t2)
T=(T2-T1)-T0
20: write(T,n)
; le compilador vectoriza esto
Graficar T vs n. La inversa de la pendiente de esta recta es r∞ . Extrapolando, se obtiene el punto de
corte con el eje de n, que es n1/2 .
Una de las grandes ideas de Cray fué tener un nV pequeño. P.e., las máquinas japonesas tienen startup
50-100% mayor que Cray.
4.7
Trampas y falacias
Trampa Incremente el desempeño vectoreial e ignore desempeño escalar. La situación tı́pica es que 50%
del tiempo se dedica a oper. escalares. Ej: si nos concentramos en mejorar por 4 veces el perf. vectorial,
obtenemos
T
4T
S=
=
= 1.6
0.5T + 0.5T /4
2.5T
Falacia Puede obtener desempeño vect. sin anchode banda de mem. Cray-1 mejoró desempeño en LINPACK por factor 2x usando transformaciones sofisticadas que permitieron retener + datos en reg.
5
Sub-sistema de memoria
archivo: memoria.tex
1 clase
5.1
Cache
¿Por qué cache?
• CPU performance
– antes de 1985: 1926% crec. anual en
velocidad
– después de 1985: 50100%
• Memoria principal (DRAM): 7% anual
=⇒un nivel adicional en la jerarquı́a de memoria que siga el paso (CACHE, hecha en SRam, más cara),
cuya eficiencia se basa en la localidad espacial: “ Si un item es referenciadp, pronto items cercanos serán
referenciados también”.
Tendencias
1970 1980 1990
Cache en sist. comerciales
2K
8K
256K
Cache en supercomputadoras
(vectoriales)
16K 64K
1M
“A medida que la capacidad de memoria aumenta de 107 bytes a 108 y 109 , hay una fuerte probabilidad
que el cache no crezca linealmente con la memoria ppal. En efecto, varios constructores, tales como Amdhal
y Hitachi han producido máquinas con 2 niveles de cache” (Stone)
5.2
Organización de un cache
Directorio del cache (bits de control, ver más adelante)
Conjuntos asociativos de lı́neas8 o bloques: Varias alternativas para esto.
• Correspondencia directa (Direct Mapped): el bloque i de memoria ⇒lı́nea mod Número de lı́neas
del cache (un conjunto asociativo). Ej: Sea un cache de 8Kbytes, organizado en 128 lı́neas de 16
palabras de 4 bytes cada una (1 lı́nea = 64 bytes). Para obtener la posición en el cache de una
dirección ADD (en bytes):
Lı́nea =(ADD div 64) mod 128
El cache necesita guardar sólo los bits más significativos de la dirección para saber cuá de los
posibles bloques de memoria se encuentra en el bloque de cache. Ventajas: costo de impl. en
HW es bajo. La polı́tica de reemplazo es trivial. Desventajas: puede haber reemplazo aunque
cache no esté lleno. Mal desempeño si se requieren dos bloques mapeados al mismo bloque.
• Totalmente asociativa (Fully associative): cada bloque de la memoria puede estar mapeado en
cualquier bloque del cache. Esto implica que para obtener una dirección ADD, se debe buscar de
manera asociativa en el campo de la dirección (el cual debe contener todos los bits de dirección
de la lı́nea). Ventajas: Uso eficiente del cache, buena tasa de aciertos. Desventajas: El costo
en HW y tiempo de tener una memoria totalmente asociativa y de bus’queda.
• Asociación por conjuntos (Set associative): El cache se divide en grupos (sets). Cada bloque
de memoria está mapeado a uno de los grupos. Dentro de cada grupo, un bloque puede ocupar
cualquiera de las lı́neas. Es equivalente a dividir el cache en n sub-caches directamentre mapeados.
Un n-way set associative cache define un cache donde cada grupo tiene n bloques. Ejemplo: mismo
cache que antes, pero 2-way ass. Para saber si ADD está en el cache, determinamos en que grupo
está mapeado, y luego hacemos una búsqueda asociativa en los bloques del grupo
Grupo =(ADD div 64) mod (Tamaño del cache (128) / n (2) = 64)
El set-ass. es el más común. La heurı́stica es que la tasa de fallas (miss rate) de un cache directamente
mapeado de tamaño X es aprox. el mismo de un 2-way de talla X/2.
5.3
Polı́ticas a definir para manejo de cache
Polı́tica de colocación:
depende de la organización.
Polı́tica de extracción:
(Cómo y qué inf. entra al cache)
extracción por demanda
extracción anticipada (prefetching): Al fallar ref., traer i e i+1. Al ref. por prim. vez linea i en cache,
traer i+1.
extracción selectiva Datos que no pueden ser traı́dos al cache. (eg: datos compartidos)
Polı́ticas de reemplazo (qué lı́nea sale del cache): LRU, al azar (HyP encuentran que azar y LRU son
ambos buenos a partir de cierta cap. de cache, pero azar es más barato)
5.4
Problemas abiertos
Un cache único o varios (Ej: instr., escalares, vectores). Un sólo cache permite que el sist. busque
mejor, pero puede haber contención. La tendencia en maq. escal./superescal. es a más de un cache.
Tamaño: La curva del beneficio resp. al tamaño (en miss rate) descelera a partir de cierto punto:
empı́ricamente, duplicar tamaño, reduce % fallas en 30%.
Tamaño de lı́nea: depende del modelo de accesos. Si hay una alta localidad espacial, mientras mayor
tamaño mejor (pero el stride puede invalidar esto!). En cambio, si hay varios puntos de localidad, es preferible
más lı́neas más pequeñas. Esta última es la tendencia excepto en máquinas vctoriales.
5.5
Efecto de las fallas
La pérdida se modeliza de la sgte manera:
tef f
= tcache + (1 − h)tmain
h es el hit rate. Si main es 10 veces más lento, decrementar h de 0.99 a 0.98 incrmenta tef f en 10%. Un
incremento de 10% en h duplica tef f tcache depende de la organización.
5.6
Cache en arq. vectoriales
La mejora de cache en arq. vect. es muy discutida. Generalmente, los pbs en algebra lineal usan una
cantidad de datos que sobrepasa de lejos la cap. de los caches. Además, si el stride es mayor que el tamaño
de la lı́nea, estaremos trayendo lı́neas al cache frecnetemente. En conlcusión, en lugra de mejorar puede
empeorar!.
CRAY no tiene cache, sino bloques de reg. usados explicite. por programador. ¿Cómo debe ser un cache
para vectores? Grande para contener todo un vector? ¿Pequeño y contener muchos fragmentos de vectores?
OJO: Accesos seriales a vectores atentan contra el cache con LRU, ya que la carga de un vector puede
vaciar (flush) un cache entero y dejar solo data inútil. Entonces, qué polı́tica usar. Problema abierto.
Stone concluye que “Los registros vectoriales deben ser organizados como registros accesibles por el
programa en vez de cache hasta que se sepa como mejorar desempeño con cache organziado por vectores.
5.7
Polı́ticas de actualización de mem. ppal
Write-through: actualizar directamente la palabra modificada en cache ⇒cache y mem. siempre consistentes. ¿Qué hacer si al tratar de escribir hay falla de cache? Alternativas:
1. write-through-with-write-allocate: escribir en mem. ppal, y traer bloque act. al cache.
2. write-through-with-no-write-allocate: sólo escribir en mem. ppal.
DEJAR QUE PIENSEN
Analizar alternativas resp. dato empı́rico: 5–30% de operaciones son de escribir 70-95% de lectura. (en
relaidad estos datos no son de gran ayuda. Los wites vienen en grupos o no? La localidad de ref. se mantiene
durante las sec. de write?
Write-back: En caso de falla de escritura, traer bloque al cache. Ensuciar(poner bit de “dirty”) solo cache
y act. mem. ppal cuando se reemplace el bloque del cache. Variantes:
• Write-back simple: esc. en mem.ppal el bloque reemplazado. (no usa bit “sucio”).
• Flagged Write-back: escribir sólo si tiene bit de “sucio” en ON.
En reemplazo, dar prioridad a traer nuevo bloque, para solapar overwriting con oper. del procesador. Esto
requiere un bloque de registros de “escrituras en curso”.
5.8
Cache y E/S
¿Dónde colocar el cache?
a)
b)
CPU -------
CACHE ------ MEM. PPAL
|
|
I/O PROCESSOR
CPU -------
CACHE
------ MEM. PPAL
|
|
I/O PROCESSOR
a) tiene demasiada actividad en cache.
b) es preferible resp. desempeño pero ... consistencia lógica entre CAHE y mem. debeser exacto para evitar
que CPU encuentre un valor y I/O Proc. otro. Solución posible: usar write-thru para cosnistencia ree.
escrituras en cache y Mem se entera de cambios en cache. Pero ¿Cómo se entera cache de cambios en Mem?
• I/O Proc. debe invalidar datos en cache, y forzar que se produzca un cache miss simulado, prendiendo
bit “corrupted” en directorio.
• I/O Proc. escribe nuevos datos en cache en vez de invalidar. “Para la mayor parte de los sistemas, la
prob. que un update conlleve a un cache hit es baja y no justifica el tráfico extra hacia el cache”.
Pero, y si quiero (me conviene) usar write-back para disminuir tráfico
CPU -------
CACHE ------ MEM. PPAL
\
/
\
/
I/O PROCESSOR
El I/Oproc. conserva una copia del directorio del cache. Esto es necesario para poder invalidar.
En write-back, el I/O pide datos en CACHE (revisa si está en dir). El dir. se actualiza para ambos solo
si hay un cache miss.
6
CASO MAQUINA VECTORIAL: CRAY
archivo: crays.tex
6.1
CRAY Y-MP C90
Tomado de [Cra92]
6.1.1
Generalidades
La C90 posee 8 o 16 procesadores.
Posee soporte para multitasking en cada procesador, paralelismo (un programa corriendo en varios procesadores) y Autotasking (partición automática de programas en CFT77 en tareas para ejecución en varios
procesadores). Posee dual-mode.
6.1.2
Pipelining and segmentation
Todo el hardware está completamente segmentado. Esto implica que todas las operaciones (exchange sequences, memory ref, inst. fetch sequences, inst. issue sequences y unidades funcionales) entregan un
resultado por CP9
6.1.3
Sección de comunicación inter-procesadores (ICS)
EL ICS contiene registros y semáforos compartidos para pasar datos e información de control entre porocesadores. Además contiene lógica que permite a un CPu interrumpir a otro y hacerlo cambiar a modo monitor
(especial para multitasking).
Los reg. y semáforos comp. están divididos en grupos idénticos (clusters) de 8 32-bit shared address
(SB) reg., 8 64-bit shared scalar (ST) reg, y 32 sem. (SM) de 1 bit. Cada CPU está asignado a un cluster,
a cuyos reg. tiene acceso.
Para transferir datos entre CPUs, un CPU carga los datos en registros compartidos desde sus registros
escalares o de dirección, luego otro CPU asignado al mismo cluster puede leerlos.
Los reg. semáforos permiten a un CPU de suspenderse temporalmente para sincronizarse con otro. Cada
CPU puede prender o apagar un SM reg de su cluster, y luego realizar un Test and Set sobre esos reg. Un
TAS sobre un SM ejecutado por un CPU puede hacer que su operación se suspenda hasta que otro CPU
apague el SM. El HW detecta si todos están haciendo TAS (deadlock).
6.1.4
Sección de cómputo del CPU
Registros
Dirección: 8 reg. A y 64 reg. B, de 32 bits c/u. Los A sirven especialmente para referenciar la memoria
o como ı́ndices, además de control de lazos, oper. de I/O, etc. Los B sirven para almacenamiento
intermedio de los A.
Escalares: 8 registros S y 64 registros T, de 64 bits c/u. Los S son fuente y destio de oper. escalares. Los
T sirven de respaldo a los S (intermediate storage); pueden usarse para traer de o llevar datos a la
memoria.
Vectores: 8 reg. de 128 elementos de 64 bits c/u. Estos sirven de fuente y destino para los dos pipes, uno
para elem. pares y el otro para impares. Además, posee un reg. VL (8 bits, 1 a 128) y un reg. de
máscara VM.
9 CP
es Clock period.
Unidades funcionales
Dirección: un sumador y un multiplicador.
Escalares: cuatro unidades de tipo entero, de uso exclusivo: sumador, lógico, shift, population/parity/leading zero.
Tres unidades flotantes compartidas con los vectoriales.
Vectoriales: 2 grupos de enteros de uso exclusivo: pipe 0 (para los pares) y pipe 1 (para impares). Cada
grupo tiene: sumador, shift, dos lógicos (uno full), vector population/parity/leading zero.
Unidades de Punto Flotante
Hay dos grupos con tres unidades c/u. Los vect. pueden usar los dos grupos (uno para pares, otro para
impares), los escalares solo uno. En vect., los oper. pueden ser vector con vector, o escalar con vector. las
unidades son: un sumador, multiplicador, reciprocal aprox.
6.2
Sección de control del CPU
La ejecución de las tareas asignadas a cada CPU son controladas a través de tres secuencias: exchange, fetch
and issue.
• La secuencia Exchange permite arrancar la primera tarea o hacer un cambio de contexto, trayendo un
bloque de parámetros (reg. A y S, P, et.) de programa (exchange packages) a los registros y salvando
los previos.
• La secuencia de Fetch arranca inmediatamente después de un exchange, y trae un bloque de inst. a
un buffer de inst.
• La secuencia de Issue selecciona la inst. apuntada por reg. P para ejecución, incrementa P, etc.
Cuando un issue no encuentra la inst. en el buffer, otra secuencia de Fetch es arrancada y un bloque es
traido al siguiente buffer.
6.3
Procesamiento paralelo
• Las unidades func. son independientes: pueden operar concurrentemente si no hay conflicto (de datos
o estructurales).
• Los dos pipes vect. permiten operar concurrentemente sobre dos secciones de los vectores, lo cual junto
con el chaining pude dar, p.e., 2 sumas y dos mutl. flotantes por CP10
6.3.1
Memoria
La memoria central de 256 Mwords es compartida. Cada CPU tiene 4 puertos a la memoria (vector, T, B,
Exchange par. reg), c/u con ancho de dos palabras (hasta 8 referencias simultáneas en cada CPU). Pueden
hacerse accesos bi-direccionales (lectura y escritura simultánea).
6.3.2
I/O
La sección de I/O comparte un puerto entre todos los CPU.
10 CP
= 4.2 ns, implica un peak perf. de 4/4.2 Gigaflops
6.4
Programación
• CAL: Cray assembler lang. UNICOS (Unix de CRAY).
• Macrotasking: usando llamadas de librerı́a (desde Fortran, pe.e.) permite ejecución en varios proc. de
varias trareas cooperantes. Paralelismo de grano grueso.
• Microtasking: Paralelsimo de grano fino, que permite ejecución paralela de pequeños segm., pro ejemplo, iteraciones de un DO. El scheduling es dinámico. Se utiliza dando directivas al compilador.
• CFT77: posee autotasking y vectorización.
• C (Ansi), Pascal, Ada, Lisp. Además, librerı́as, utiliatrias, software de com. (TCP/IP, etc).
7
Cray Y-MP E
Tomado de [Cra91]
7.1
Generalidades
Máxima configuración: 8 CPU. Memoria de 256 Mwords, 4 secciones y 256 bancos.
7.1.1
Diferencias con C90
• Max de 8 CPU contra 16 de C90.
• Registros vect. de 64 elementos, en vez de 128 en C90.
• Buffer de instrucciones de: 4 para un total de 512 parcelas de 16 bit, mientras que 8 para C90 (total
de 1024 de 16bit).
• Sólo un grupo de unidades funcionales enteras y flotante para vectores. La C90 tiene dos grupos (pipe
0 y pipe 1) para procesar cada CP dos ele. de cada vector operando.
• CP de 6 ns, contra 4.2 ns, 1 VM contra 2.
• Memoria: 256 bancos en 4 seciones, contra 1024 en 16. Tiempo de acceso de 15 ns, con un bank busy
time de 102 ns. Total BW memoria es 32 words/CP por procesador
• 9 clusters max, contra 17.
• 1 CPU en 1987, primeras entregas en 1988. 25 M$.
Performance
8
Pico de 4 Gflops.
CRAY-1
[DD89]
• Monoprocesador, introducido en 1976
• 4 tipos de chips de 2 compuertas por chip, en ECL, con .7 ns de retardo por compuerta.
• 12.5 ns CP.
• 4 Mwords (CRAY-1S) de 64 bits de memoria (bipolar, menos 1-M, MOS), en 16 bancos. El busy time
de un banco es 4 CP, y la latencia es 12 CP.
• 8 Reg. vect. de 64 elem. de 64 bits.
Performance
8.1
Max. perf: 160 Mflops. Max. escalar: 80 Mips.
CRAY-2
• 4 procesadores, con pipelining y overlapping pero sin chaining. Los pipes tienen más segmentos que
CRAY-1
• Memoria Compartida: 256 Mwords de 256 K DRAM en 128 bancos. El bank busy time es 57 CP, y el
acceso escalar es 59 CP.
• Memoria local: 16 Kwords, 4 CP de local a vector reg.
• CP de 4.1 ns
• Mucho overhead para oper. vectoriales: 63 CP para cargar y guardar vector, 22 para vector multiply
y add.
• Gran mejora respecto a I/O.
• Costo: 15-20M$
Performance
proc.
8.2
Pico: 488 Mflops por proc. Código de multiplicación de matrices corre a 1.7 Gflops sobre 4
CRAY-3
• Versión en GaAs de CRAY-2, desarrollada por S. Cray (Cray Computer Company)
• CP de 2 ns.
• 16 proc.
• Memoria de 512Mwords estática con 256 o 512 bancos, bank busy time de 25 ns, tiempo de ciclo de
memoria de 50 ns. 2 puertos a memoria por CPU. Total BW de memoria 16 veces CRAY-2
• VR tailgating emula chaining
• Pico de 16 Gflops
• Liquid colant inmersion
• Elimina desbalance de CRAY-2 aumentando velocidad escalar a 4 veces CRAY-2.
• Precio alrededor de 25-30 M$
8.3
CRAY X-MP
• Hasta 4 proc.
• Cada propc posee misma arquitectura que CRAY-1, excepto que tiene 3 vı́as a la memoria, y CP de
8.5 ns.
• Memory hasta 16 M y 64 bancos. El modelo X-MP-4 ECL tiene bank busy time de 34 ns y tiempo de
acceso de 14 CP
• Incorpora SSD
• Costo de 25 a 30 M$
• Anunciada en Agosto 1982, primera entrega en Junio 1983
9
Introducción a MIMD
archivo: mimdint.tex
3 horas aprox
Fuentes:
9.1
El Stone, el Almasi & Gottlieb y notas personales.
Definición y objetivos
Según Flynn (1972), un computador MIMD es “una máquina que comprende mútiples unidades procesadoras,
cada una de las cuales ejecuta su propia secuencia de instrucciones independientemente sobre datos locales,
cooperando en la solución de un problema, gobernados por un mismo sistema de operación, de manera
ası́ncrona”.
Esta definición lo diferencia claramente de los sistemas distribuı́dos, y de los otros tipos de máquinas con
paralelismo (Vectorial, SIMD, etc). Sin embargo, habrı́a que aclarar que los “datos locales” no significa que
no pueden compartir datos. Lo que Flynn debı́a tener en mente es que cada procesador trae (al CPU) su
propio conjunto de datos para procesar.
El interés del MIMD reside en el potencial de ejecutar una tarea, que tarda un tiempo T en un procesador,
en un tiempo T/N en N procesadores, es decir, alcanzar un Speedup de N con N procesadores. Podemos ver
los beneficios potenciales del MIMD de dos puntos de vista:
Costo: una máquina MIMD con un número suficiente de procesadores podrı́a substituir (provee mismo
performance) una máquina costosa (mainframe o supercomputador). Debido a que el costo de dichos
procesadores es bajo, el costo del MIMD serı́a mucho menor que el de la máquina reemplazada.
Velocidad: Dado un desempeño deseado, basta con agregar un número de procesadores suficiente para
alcanzarlo.
Al concepto de crecimiento del desempeño con respecto al número de procesadores se le denomina escalabilidad.
9.2
Modelos de desempeño
El desempeño real obtenido en una máquina MIMD se vé limitado por factores ligados a la naturaleza de la
tarea a ejecutar y a la arquitectura.
Limitaciones inherentes a las aplicaciones: Ya en 1967 Amdahl estableció que las aplicaciones no eran
completamente paralelizables. En cambio, propuso un modelo de las aplicaciones dividido en dos partes:
una parte o fracción paralelizable y una fracción serial. El speedup está acotado (ver clase performance) por
la fracción serial.
Limitaciones inherentes a la arquitectura: Una tarea que es repartida en una arquitectura MIMD,
necesitará que sus partes se comuniquen (intercambiando datos, por ejemplo) para cooperar en la ejecución
de la tarea, salvo en el muy excepcional caso (pero que existe) en que no hay necesidad de comunicación y
todos los procesadores tienen un canal propio de E/S. Al tiempo de ejecución de las tareas debe agregarse el
tiempo invertido en la comunicación, el cual es puro overhead respecto al secuencial, donde no existe. Este
tiempo de comunicación puede a su vez dividirse en dos partes, si la arquitectura permite solapamiento de
comunicación y cálculo (ej: Transputer).
La expresión del Speedup S generalizado que toma en cuenta todos estos factores es:
S
=
tsec.
fs .t + (1 − fs )tsec. /n + fno−sola. .tcom
• tsec. es el tiempo que tarda la aplicación en un solo procesador
• fs es la fracción serial de la aplicación, 1 − fs es la fracción paralelizable.
• n es el número de procesadores.
• tcom es el tiempo total de comunicación, fno−sola. es la fracción de ese tiempo que no es solapada con
los cálculos.
9.3
Granularidad
Una aplicación puede representarse como un grafo dirigido, cuyos nodos son las sub-tareas que la componen,
y los vértices la dependencia de datos entre tareas. Una arquitectura paralela también puede representarse
como un grafo dirigido, cuyos nodos son los procesadores y los vértices los canales de comunicación entre
nodos.
La granularidad de una tarea es una medida del tamaño de las sub-tareas que la componen11 . La expresión de la granularidad de una tarea, es decir, su partición en tareas, reposa a menudo sobre el usuario.
Para ello, este dispondrá desde directivas del compilador (es el caso tı́pico de garnularidad gruesa en supercomputadoras, incluso Cray tiene compiladores paralelizantes) hasta lenguajes paralelos con diferentes
niveles de granularidad (occam, ADA, etc.) o con granularidad fina (Data-Flow).
La granularidad de una arquitectura expresa la potencia de cálculo de los nodos.
Mientras mayor sea la granularidad, menor será la necesidad de comunicación entre nodos (es decir,
menor será el overhead) pero también será menor el paralelismo aprovechado de la aplicación.
El objetivo de la partición de una aplicación es de obtener un nodo para cada procesador de la arquitectura. Los parámetros pueden ser varios: número de nodos y topologı́a de la arquitectura, número de
nodos de la aplicación. Hay una gran interrlación entre éstos. Por ejemplo, podrı́a fijarse la arquitectura y
tratar de encontrar una partición de la aplicación que se adapte bien a esa arquitectura. O al revés, dada
una partición, encontrar una topologı́a y número de procesadores de la arquitectura que se adapte bien a la
partición.
Stone presenta el siguiente modelo para expresar granularidad. Se tienen M tareas y N procesadores. Al
distribuir las tareas en esa máquina se obtiene un quantum de ejecución R y un overhead de comunicación
C para ese R. El factor R/C es una medida de la granularidad.
• R/C grande =⇒alta (gruesa, coarse) granularidad: puede no aprovecharse el paralelismo.
• R/C pequeño =⇒baja (fina, fine) granularidad: el overhead es mayor que el beneficio obtenido
9.4
Conclusiones sobre el desempeño
• El procesamiento en paralelo en MIMD agrega un overhead que no existe en mono-procesador. Este
overhead incluye: scheduling, contención, sincronización y comunicación entre procesadores.
• Agregar procesadores tiende a disminuir la parte computacional, pero incrementa el overhead. Este
puede incluso crecer más que linealmente.
• El objetivo del diseñador de arquitecturas es obtener una máquina “balanceada” en R/C. Sin embargo, esto es fuertemente dependiente de las herramientas de compilación y de aprovechamiento de
paralelismo de una tarea. Como ejemplo, tenemos la CM-1, con un tremendo desempeño en ciertas
aplicaciones.
Falacias [Stone] Una máquina de muchos procesadores de tecnologı́a obsoleta pueden reemplazar a una
máquina pequeña (pocos o un procesador).
La máquina paralela siempre se hará más cara cuando sus componentes se irán poniendo obsoletos, su
producción (oconstrucción) se encarecerá. Además, la necesidad de herramientas especiales para máquinas
paralelas hace que el costo de la segunda crezca con el tiempo.
Podemos obtener el desempeño deseado con solo agregar el número de procesadores suficiente.
11 Este
modelo asume que las tareas son divididas en granos relativamente iguales.
Esto ya fué invalidado con la presentación de los modelos más acordes con la realidad. El trade-off en
R/C puede verse de la siguiente manera: ¿cuántos procesadores necesito para alcanzar un desempeño dado?
Esto, si es posible, tendrá un costo creciente con el número de procesadores. Si para aumentar el desempeño
en 30% debo multiplicar por dos el número de procesadores, podrı́a pensar que no tengo el rendimiento que
justifique la inversión.
9.5
Taxonomı́a de MIMD
Entre las múltiples taxonomı́as de arquitecturas que se han publicado, tomaremos aquı́ solamente dos.
La primera clasifica las máquinas únicamente por el número de procesadores que posee. La clasificación
es:
Paralelismo bajo: incluye las máquinas con menos de 20 procesadores. Mi heurı́stica para determinar el
corte es el número de procesadores de CRAY, actualmente en 16 (CRAY Y-MP C90).
Paralelismo mediano: entre 20 y 1000 procesadores.
Paralelismo masivo: más de 1000 procesadores.
Todos estos números dependen de la tecnologı́a y de la granularidad. Uno puede pensar que el costo
de una máquina crece con n. Para n masivo, el costo de cada procesador no puede ser muy grande, p.e,
CM-1 con procesadores muy sencillos (1 bit). En cambio, para n pequeños, se puede tomar lujos en los
procesadores, p.e., CRAY. Sin embargo, con los avances tecnológicos cada vez tenemos máquina con nodos
potentes que desafı́an esta regla (e.g.: Delta de intel, Ncube, CM-5, etc).
La segunda taxonomı́a atañe solo a los MIMD. Esta los clasifica de acuerdo a la conexión procesadoresmemoria. La memoria, como vimos en pipeline, también debe paralelizarse para aceptar accesos simultáneos.
Tendremos entonces un conjunto de módulos de memoria y un conjunto de procesadores.
Memoria Compartida: Cada procesador tiene acceso a cualquier módulo de memoria. El acceso se realiza
a través de una Red de Interconexión (RI). Los procesadores comunican a través de variables compartidas.
Memoria Distribuı́da: Cada procesador tiene solo su memoria local. La comunicación de datos o acceso
a otros módulos de meoria se realiza por intercambio de mensajes entre procesadores. Los procesadores están
conectados a través de una RI.
M1
P1
M1
P1
M2
P2
M2
P2
RI
..
.
Mm
..
.
Pn
..
.
Mn
..
.
Pn
RI
10
Redes de Interconexión
archivo:ri.tex, ruteo.tex
10.0.1
Introducción
Permiten la conexión de procesadores a memorias (en SIMD y MIMD/SM) o entre procesadores (MIMD/DM).
Parámetros a considerar en RI
1. Latencia: cuánto tarda un mensaje (pedido de acceso) en atravesar la red.
2. Ancho de banda: qué tráfico soporta.
3. Conectividad: capacidad de establecer conexiones
4. Costo del Hardware: depende del número de elementos de comuntación.
5. Fiabilidad: capacidad de funcionamiento en caso de falla de algún componente.
6. Funcionalidad: qué tipo de funciones incorpora la red (e.g.: recombinación para “hot spots”).
El ancho de banda de una RI es una medida de la capacidad de accesos simultáneos que ella provee. El
ancho de banda promedio consumido BWc será una función de la probabilidad de acceso de cada procesador,
del número de procesadores, del tiempo del ciclo de acceso y de la cantidad de información (bits) de cada
acceso.
Caracterı́sticas de una RI
• Estática (MIMD/DM) o Dinámica (conexiones programables)
• Modo de operación: sı́ncrono (e.g.: SIMD) o ası́ncrono.
• Método de conmutación: por paquete o por circuito.
A continuación presentaremos las RI dinámicas. Las estáticas, usadas únicamente en MIMD/DM, son
descritas en la clase sobre MIMD/DM.
10.1
Buses
Un bus une en una misma vı́a de acceso un conjunto de procesadores y memorias. La gran ventaja del bus es
la economı́a en hardware, por ello su uso en sistemas baratos. El acceso al bus se hace en exclusión mutua,
lo cual produce contención: un acceso debe ser pospuesto debido a que hay otro en curso.
Sea un sistema con N procesadores conectados por un bus a una o más memorias (elementos pasivos).
Las caracterı́sticas del sistema son:
Ancho de banda (por procesador): proporcional a 1/N
Latencia:
constante (resp. a N)
Conectividad:
cualquiera con cualquiera
Costo en hardware:
en cable y en conmutadores es prop. a N
Fiabilidad:
Débil
Control de acceso al bus: Para controlar el acceso en exclusión mutua al bus, existen varios protocolos,
entre ellos: daisy chainning (prioridad al más cercano), fixed time slice, LRU, rotating daisy chaining, FIFO.
Ancho de banda El BW en un bus será expresado en función del ciclo de acceso, del tamaño del bus (que
define la cantidad de bits en cada acceso).
Sean p procesadores conectados a una o más memorias a través de un bus. Supongamos que, en cada
ciclo de acceso, la probabilidad de que un procesador accese al bus es independiente del resto e igual a r. La
probabilidad de que no accese al bus es entonces (1 − r). La probabilidad de que ningún procesador accese
al bus es (1 − r)p . La prob. de que haya al menos un acceso al bus es 1 − (1 − r)p . Como el bus solo atiende
un pedido en cada ciclo, el promedio de pedidos de acceso atendidos por ciclo es igual a la fracción de ancho
de banda consumida:
FBW
1 − (1 − r)p
=
Mientras más cercano sea a 1 FBW , mayor será el ancho de banda consumido, es decir, que habrá mayor
competencia por el bus y mayor contención (el bus se satura). Nótese que a mayor r, más rapidamente se
satura el bus respecto a p. El ancho de banda es:
BWc
= FBW ×
AnchoBus bits
tc iclo segundo
Los pedidos que no son atendidos, serán reemitidos al ciclo siguiente, por lo que la rata r aumenta a una
nueva rata aumentada a. Bajo una polı́tica equitable de otorgamiento de acceso al bus, la probabilidad de
que un pedido sea aceptado es (asumiendo independencia e igual probabilidad entre procesadores):
Pa
=
1 − (1 − a)p
pa
Multiples buses Tener múltiples buses mejora con respecto a un solo bus, pero debido a que el costo en
cable y conmutadores depende del ancho del bus, esto hace prohibitivo su uso (ver x-bar). Varias máquinas
multi-bus han fracasado, la última fué la SUPRENUM.
10.2
Conmutadores de barras cruzadas o x-bar
Los conmutadores x-bar son herencia de la telefonı́a. Un x-bar es una matriz de conmutadores elementales
N × M que permite la conexión de N objetos de entrada a M objetos de salida. Estos objetos pueden
ser procesadores y memorias (es el caso de MIMD/SM y SIMD) o únicamente procesadores (MIMD/DM).
Cada conmutador cij tiene dos estados: ON, conecta el objeto de entrada i al objeto de salida j; y OFF (no
conectado).
Ancho de banda (por procesador): constante
Latencia:
constante (resp. a N )
Conectividad:
cualquiera con cualquiera libre
Costo en hardware:
en cable prop. a N y en conmutadores prop.
a N2
Fiabilidad:
Alta
La operación de una red x-bar necesita la programación del estado de cada conmutador, en función de
la fuente y el destino. Este control debe estar a cargo de alguien (árbitro) para evitar conflictos sobre una
lı́nea.
El tipo de conmutación de x-bar es conexión de circuito tı́picamente, lo cual permite comuicación en
ambas direcciones. Nótese que el costo en conmutadores crece con el cuadrado de N . Si tomamos en
cuenta el ancho de las lı́neas, entonces tenemos que el número de conmutadores es igual a (Ancho×N )2 . Si
tomamos en cuenta que el ancho es la suma del ancho del bus de datos (e.g: 32) más parte del ancho del bus
de direcciones (entre 20 y 30 bits) tenemos una idea de los prohibitivo de esta opción con buses.
Una memoria multi-puerto (como la usada en Cray’s) equivale a este esquema. Es por eso que N es
pequeño.
Ancho de banda El ancho de banda de un x-bar puede estimarse analı́ticamente como en el caso del
bus, a diferencia que en x-bar habrá un número promedio de solicitudes aceptadas por ciclo. Existen otras
técnicas de estimación del desempeño, tales como: colas y cadenas de Markov, simulación, midiendo en
sistema real.
Tenemos una red x-bar que une p procesadores a m módulos de memoria. Se asume: pedidos sı́ncronos
(a principio del ciclo), accesos aleatorios, equiprobables (Prob. de que Pi accese a mj = 1/m ya que a cada
ciclo un P debe accesar un mo’dulo)) e independientes entre sı́, independencia entre nuevos y rechazados.
FBW
= m(1 − (1 − 1/m)p )
Nota: el ideal es m. Si m/p es constante, tiende a una cosntante.
En el caso de que los procesadores tengan memoria local, y de los MIMD/DM, no siempre habrá acceso
a través de la red. Sea r la probabilidad de que un procesador solicite un acceso a la red.
FBW
= m(1 − (1 − r/m)p )
Nota: crece con p y con m La probabilidad de aceptación de un acceso es
Pa
10.3
=
FBW
rp
Redes Multi-etapas
Objetivo:
ofrecer una buena conectividad a un costo en conmutadores menor que el x-bar.
Precio a pagar: latencia (varias etapas a atravesar en vez de una); conectividad (capacidad de conexión).
Estudiados en telefonı́a por Clos y otros desde los años 50. Clos determinó los parámetros de interés de
una red.
Capacidad no-bloqueante: una red es sin bloqueo si es capaz de establecer una conexión entre una entrada
y una salida inactivas sin alterar las otras conexiones.
Capacidad de ser re-ordenable: (en inglés rearrengeable). Una red es reordenable si es capaz d establecer
una conexión entre una entrada y una salida inactivas eventualmente redistribuyendo las conexiones
existentes.
Ciertas permutaciones son particularmente relevantes:
• Shift (up and down): (cálculo de matrices, acumulaciones)
Shif t(a0 , . . . , an−1 ) = an−1 , a0 , . . . , an−2
• Perfect Shuffle: (barajadura en el H y B) si n es par
P S(a0 , . . . , an−1 ) = a0 , an/2 , a1 , an/2+1 , . . .
• Identidad
Construcción: cada etapa consiste de un número regular de x-bar (a × b). Las salidas de la etapa i son
las entradas de la etapa i + 1 según una permutación fija.
Las redes multi-etapas se clasifican en dos familias: Clos (variantes de la red original general descrita por
Clos) y Banyan (redes que surgen de establecer un árbol de conexión entre cada entrada y cada salida).
A la familia de Clos pertenece Benes. A la familia Banyan pertenece Omega, Shuffle, Shuffle-exchange,
Baseline.
10.3.1
Red de Clos
Una red de Clos C(p, q, r) posee tres etapas, y conecta p × r entradas a p × r salidas. Sus propiedades son:
q ≥ p =⇒Re-ordenable
q ≥ 2p − 1=⇒No-bloqueante
El costo en conmutadores (puntos de cruce) es 2rpq + qr2 en lugar de p2 × r2 del x-bar.
10.3.2
Red de Benes̆
Es una red de Clos C(2, 2, 2N −1 ), con 2 log2 N − 1 etapas, y N/2 conmutadores elementales por etapa. Como
q = p = 2, la red es re-ordenable.
Inconveniente: el cálculo del control de los conmutadores es complejo. La solución (usada en GF-11,
576×576 SIMD para interconectar procesadores) es de tener una tabla para las permutaciones más frecuentes.
Se determina a la compilación.
10.3.3
Redes Banyan
Una red de Banyan se define como todas aquellas que poseen un sólo camino entre cada entrada y cada
salida. Su costo crece en n log n, por lo cual son mucho más económicas que las redes Clos. Por el contrario,
son altamente bloqueantes, pero su programación e implementación son muy sencillas. Son tag-directed
=⇒packet switching
Una red Banyan se caracteriza como B(a, b, l), donde l es el número de etapas, y los elementos de
conmutación en cada etapa son a × b, conectando al entradas con bl salidas. En l etapas de a × a, una
entrada puede enviarse sobre al .
El número de conmutadores es #C = al+1 l. Si n = al , entonces #C = n × log n × a/ log a
Una red Delta es una red Banyan, en la cual las conexiones entre etapas se hacen en perfect shuffle.
Problema: no hace identidad
Entre las redes Banyan más populares está la red Omega, la cual es equivalente a un hipercubo.
10.3.4
Desempeño y ancho de banda
Utilizando el modelo analı́tico, y con las asumpciones tomadas para el caso del x-bar. El ancho de banda se
calcula en cada etapa. Si los elementos de conmutación son a × b y hay l etapas, entonces:
BW = bl rl
Pa =
bl rl
al r
Donde ri = 1 − (1 − ri−1 /b)a
10.3.5
Conclusión redes multi-etapas
Clos costosa en conmutadores, difı́cil de programar, usada para sistemas grandes, SIMD (por reordenabilidad), circuit switching
Banyan Util para packet switching, problema de bloqueo, muy utilizado. El problema de contención es
atenuado con recombinación de pedidos (hot spots). Esto aumenta complejidad de los switches en el
orden de 6.
11
MIMD Memoria Compartida
Motivación Los MIMD/SM tienen una serie de propiedades interesantes:
• El espacio único de memoria coincide con la visión del programador.
• El compartimiento de datos y código se hace de manera natural y económica.
• De igual manera, los accesos de E/S hacia y desde la memoria son simples.
• Soporta eficientemente los paradigmas SM y DM.
Sin embargo (veremos para memoria distribuı́da), posee algunos inconvenientes:
• No se expande facilmente (escalabilidad). Este es el mayor inconveniente de los MIMD/SM.
• Se necesitan técnicas de sincronización para controlar los accesos a las variables compartidas.
• La contención puede reducir la velocidad del sistema (ej: hot spots).
• El uso de caches para mejorar el desempeño impone el control de la consistencia de caches.
• El debugging es complicado (Manejo de semáforos, ¿Quién alteró la variable? , etc.)
Las máquinas MIMD/DM en cambio son escalables pero más difı́ciles de programar y dependientes de
la arquitectura. La tendencia actualmente es a combinar los dos esquemas de la siguiente manera: una
máquina DM a la base, con HW y SW especial para implementar un espacio único de memoria (Virtual
shared memory). Actualmente hay gran actividad en este tópico, y ya hay máquinas escalables con este
esquema hı́brido (KSR1, Dash,...).
11.1
Técnicas de sincronización
Las técnicas de sincronización entre procesos son especialmente relevantes para MIMD/SM ya que necesitan
acceso controlado a variables compartidas, y también a otros recursos ya que están fuertemente acoplados.
Estos accesos se hacen tı́picamente en exclusión mutua; la sección de código que accesa a ese recurso se
encierra en una sección crı́tica. Entre las técnicas de control de exclusión mutua tenemos los cerrojos locks
y los semáforos.
Además de sincronizarse para accesar a variables compartidas, también necesitarán sincronizaciones
generales (de control) como las barreras. Estas técnicas necesitan un apoyo especial de hardware para
ejecutarse sin conflictos en una arquitectura MIMD/SM. Veremos algunas de las más utilizadas.
11.1.1
Test and Set
Prueba el valor de una variable y la modifica de manera atómica (tı́picamente bloqueando el bus). Devuelve
el valor de la variable. Se usa para implementar LOCKS: lectura de la variable, prueba si es cero (abierto),
y si lo es lo pone en uno. Si no se hace de manera atómica, se corre el peligro de que dos procesos vean
simultaneamente la puerta abierta y entren!
LOCK(x):begin
var y:integer;
Repeat {y <- TAS(x)} until y=0
end
El LOCK (o Spin-lock) se queda en espera activa hasta que entra. Esto puede traer consecuencias terribles
en el desempeño (hot spot), además de retardar (por conflicto) el UNLOCK.
Una alternativa es el semáforo binario, que pone a dormir a los procesos en espera (puede manejar prioridades u orden de llegada para escoger cuando se libere). Esto es más efectivo que el spin-lock dependiendo
del costo de cambio de contexto. Se necesita que los procesos sean suficientemente “pesados” para que sea
más eficiente que spin-lock. Además, el manejo de la cola de procesos en espera implica el acceso a una
varable compartida: el apuntador a la cabeza de la cola (encolar debe implementarse sobre un mecanismode
spinlocks).
11.1.2
Incr y decr.
Usado para semáforos generalizados. Se lee una variable y se incrementa (o decrementa) de manera atómica.
Incr(add):
Mem[add] := Mem[add] + 1
Return(Mem[add])
Su utilización en un semáforo generalizado serı́a
LOOP: while sem < 0 do skip
if decr(sem) < 0 then
incr(sem)
goto LOOP
{seccion critica}
incr(sem)
Incr/decr provee forma fácil de implementar semáforos generalizados pero no resuelve spin/lock ni contención.
11.1.3
Compare and Swap
Reuce muchas regiones crı́ticas sobre una variable compartida a una sola instr. atómica (Ej: manipular la
var. compartida apuntador a cabeza de cola).
Debido a que el tiempo dentro de la rehión se reduce, disminuye la contención respecto a hacerlo con
semáforos.
CAS(dir,old,new):
temp := Mem[dir]
if temp = old then
Mem[dir] := new
return(true)
else
old := temp
return(false)
Problema: difı́cil de usar (ver Stone)
11.1.4
Fetch and Add
Permite acceso concurrente a uan msima variable =⇒reduce contención por hot spot (no por conflicto de
banco). Ver Gotlieb (RP3 y Ultracomputer). Más complejo que CAS.
Requiere red combinadora. El efecto es de secuencializar las operaciones sobre una variable.
FAdd(dir,cte)
temp := Mem[dir]
Mem[dir] := Mem[dir] + cte
return(temp)
1. La localidad se escribe una sóla vez para satisfacer M peticiones de escritura concurrente.
2. Los valores retornados a los M procesadores son los mismos que los que retornarı́a algún ordenamiento
serial arbitrario de accesos.
Nótese que actualizar variables tipo cuenta bancaria no requiere semáforos nio reg. crı́ticas: solo FAdd.
(Ver Stone para uso en implementación de cola de procesos)
No está cllaro si el costo de la red combinadora se justifica; nótese que los accesos deben ser simultáneos!.
11.2
Barreras
• Una barrera de sincronización es un punto al cuál deben llegar todos los procesos antes de continuar.
• Surge en paralelización de lazos (tı́picamente) y algoritmos data parallel (sincr. por iteración)
• Implementadas a menudo con un bus adicional que conecta a procesadores para efectos de control.
La implementación en HW equivale a prender u bit porprocesador indicando si ninguno a llegado, si
alguno o si todos. Por SW implica un test sobre un contador =⇒hot spot.
Existe una nueva técnica (a ser implementada en SW) de una barrera difusa, donde el compilador trata
de hacer algunas instrucciones mientras espera (ver paper Gupta y Epstein)
12
MIMD Memoria Distribuida
[2 clases]
Los MIMD/DM son arquitecturas sin espacio común de memoria, cada procesador posee su memoria
local. El acceso a datos no locales se hace por intercambio de mensaje entre procesadores. Los procesadores
de estas arqitecturas están interconectados a través de una red, que puede ser reconfigurable (dinámica) o
estática. En las dinámicas, tenemos todos los tipos estudiados en la clase de RI, y que son ampliamente
utilizadas en MIMD/SM. Las estáticas, que dan origen a topologı́as fijas, son particulares de los MIMD/DM.
Veremos las más comunes y sus propiedades.
Ventajas de la MIMD/DM:
viceversa, ver más abajo):
lo que es desventaja en MIMD/SM es ventaja para el MIMD/DM (y
• El debugging es más simple (que en MIMD/SM). Como la información se comparte únicamente vı́a
mensajes intercambiados entre procesadores, basta con analizar la traza de las comunicaciones para
detectar los problemas, en lugar de llevar trazas de todos los acesos a memoria.
• Escalabilidad: debido a que el acoplamiento es débil, el crecimiento de la arquitectura es más sencillo,
tı́picamente no hay conmutadores.
• Ancho de banda de la memoria es proporcional al número de procesadores.
En contrapartida, la DM presenta las siguientes desventajas:
• Carga de programas y datos debe hacerse en cada nodo, al igual que la salida debe permitir el acceso
desde cada nodo. Esto implica un overhead en el aranque, y en la obtención de resultados. Además, si
utilizamos replicación de datos para reducir comunicaciones, podemos traer problemas de consistencia.
• La programación es más difı́cil (menos natural)
• Menos flexible: una SM puede simular eficientemente una DM, pero no a la inversa.
• Necesidad de enrutamiento.
12.1
La comunicación
Tı́picamente, la comunicación es más costosa en tiempo que el cálculo en los procesadores, lo cuál determina
que en MIMD/DM la granularidad debe ser suficentemente alta. Para reducir este problema, se dota a los
procesadores de cálculo con co-procesadores de comunicación, que pueden funcionar concurrentemente con
los cálculos.
La caracterı́stica esencial de los DM es la comunicación. Si la red es estática, la comunicación entre
dos procesadores puede acarrear la necesidad de enrutar los mensajes. Si la red es reconfigurable, hay que
agregar la reconfiguración de la red. Es decir, necesitamos un sistema de transporte (capas 0 a 2 de redes
OSI).
Además, la comunicación de mensajes puede hacerse por paquetes o enviando el mensaje completo. Si
los mensajes son largos, vale la pena paquetizar ya que ası́ el sistema es más equitable: ningún mensaje
ocupa demasiado tiempo un enlace. Si los mensajes son pequeños, entonces puede evitarse el overhead de
enpaquetar y desempaquetar el mensaje.
El tiempo de una comunicación punto a punto puede desglosarse ası́:
• Preparación de la información P . Ej: a la transmisión tenemos paquetización, encabezados, envı́o a la
cola, y a la recepción tenemois las operaciones inversas.
• Permanencia en las colas Q. Puede haber varios paquetes compartiendo el enlace de comunicación.
• Transmisión: esto incluye el start-up de protocolo de bajo nivel (Tstartup ) y la transmisión de la
información en sı́, que depende de la rata (R) y del tamaño del mensaje (L).
• Propagación de la señal en el medio.
La fórmula del retardo D por comunicación incluye todos estos factores
D = P + Q + (Tstartup + RL)
Ej: T800
El cálculo por una comunicación punto a punto de un dato de 32 bits en el T800 es:
P + Tstartup
R
Q
L
= 2.5µs
≈ 0.07µs/bit
=⇒D = 4.7µs
= 0
= 32
Una operación flotante en el T800 tarda 0.25µs, lo cual implica una relación Cálculo por comunicación
del orden de 20!.
12.2
Enrutamiento
Es necesario cuando dos nodos que no están directamente conectados desean comunicar. En el casos de redes
estáticas, será generalmente necesario a menos que se tenga un grafo completo (raro!). En el caso de redes
reconfigurables, depende de si enrutar es más o menos costoso que reconfigurar la red.
Existen dos técnicas de enrutamiento:
Store and Forward: un mensaje (o paquete) es de nodo en nodo hasta alcanzar su destino. En cada nodo,
el mensaje (o paquete) es recibido (almacenado) completo y luego reenviado. Sea Nint el número de
nodos intermedios atravesados, la latencia es
TSF = P + Q + Tstartup + RLNint
Cut-Through: el mensaje (o paquete) es reexpedido antes de ser totalmente recibido, desdde que el encabeado es recibido y decodificado. La latencia es
TCT = P + Q + Tstartup + RL + Td Nint
En general, el CT es mejor, ya que la latencia es menor y necesita menos capacidad de buffer. Una
variante del CT utilizada en el T9000 y el hipercubo es el Wormhole Routing. La variante consiste en que
WH bloquea la ruta cuando no puede avanzar, mientras que CT guarda el mensaje en buffers hasta que la
ruta es liberada.
Cálculo de la ruta: La ruta viene dada por una función de enrutamiento R en cada nodo, que asigna el
próximo nodo-enlace para cada mensaje que pasa por el procesador. El enrutamiento puede ser:
Estático: la ruta es determinada en función del origen y destino (EJ: la ruta más corta). No hay balance
de carga.
Dinámico: la ruta para mensajes con el mismo origen y destino puede variar, de acuerdo, por ejemplo, a
la carga. Permite balancear las comunicaciones, pero el cálculo es más costoso (overhead adicional), e
implica posibilidad de desecuenciamiento.
Bloqueo: Un enrutamiento puede provocar bloqueos (deadlocks). La prevención de bloqueos es más complicada en el caso dinámico. Un bloqueo puede surgir tı́picamente por saturación de buffers. Ej: Sea un
anillo de 4 procesadores n0 − n3 , cada uno con capacidad de almacenar unmensaje en tránsito. Un bloqueo
se presenta si cada nodo emite un mensaje a un destinatario alejado de dos nodos (eg: n0 →n2 , etc.). En este
caso ningún mensaje puede avanzar hasta su destino y tenemos un bloqueo. Una solución a este problema
es de establecer canales virtuales para cada mensaje. Un canal virtual establece un buffer privado en cada
nodo para cada ruta origen-destino.
6
n2
Store and
Forward
n1
n0
n2
n1
Cut-Through
n0
Th
Tm
• Th es el tiempo que tarda en recibir y decodificar el encabezado.
• Tm es el tiempo que tarda en enviar completo un mensaje al nodo vecino.
Figure 1: Latencia según la técnica de enrutamiento.
12.3
Topologı́as fijas
Los parámetros de interés para el análisis de una topologı́a son12 :
1. Diámetro: el máximo de las distancias mı́nimas entre dos nodos cualesquiera.
2. Conectividad: medida de l número de caminos independientes entre un par de nodos. Es el mı́nimo
número de nodos o arcos que deben ser suprimidos para que la red sea disconexa.
3. Flexibilidad: capacidad de resolver problemas para otras topologı́as.
4. El número de procesadores, el número de arcos.
5. Tiempo de comunicación (latencia), para ciertas familias de comunicación:
(a) Broadcast: óptimo es O(d) (d es diámetro).
(b) Single and multi-node accumulation: equiv. a 5a
(c) Single node scatter (gather) y total exchange.
Ver
Bertsekas y Tsitsiklis “Parallel and Distributed Computation: Numerical Methods”, Prentice-Hall
International, 1989.
12.3.1
Topologı́as comunes
Lineal: Diámetro D = n − 1. Conectividad C = 1 (pobre). Ruteo simple. enlaces/nodo = 2.
Anillo: D = techo(n − 1/2), C = 2. Ruteo simple. enlaces/nodo = 2.
Arbol: C = 1 D depende del tipo de árbol:
• Estrella: D = 1
• Lineal: D = n − 1
Malla: malla de d-dimensiones, con ni nodos en cada dimensión.
(x1 , . . . , xd ), xi ∈ {1, . . . , ni }
Los arcos son los pares ((x1 , . . . , xd ), (x1 , . . . , xd )) , ∃i | xi − x0i |= 1, ∀j 6= i, xj = xi
Pd
El diámetro D = i=1 (ni − 1) = O(N 1/d − 1)
enlaces/nodo = constante(2d)
Extensible
Hipercubos: El hipercubo binario (una malla con ni = 2.) posee una serie de proiedades topológicas
interesantes que motivaron su utilización en varias máquinas experimentales y comerciales (CM-1,
iPSC, nCube, etc.):
• Hipercubo de d dimensiones posee 2d nodos.
• Cada nodo está conectado a d vecinos.
• Número de arcos total = d2d−1
• Sea un hipercubo de dimensión d, cuyos nodos están etiquetados por un número binario según
la codificación de Gray b1 , . . . , bn , donde n = 2d . Un hipercubo de dimensión d + 1 se obtiene
agregando n nodos con las etiquetas tomadas de manera que
b1 , . . . , bn −→0b1 , . . . , 0bn , 1bn, . . . , 1b0
12 Estos
parámetros son aplicables a redes de interconexión en general.
• Posee d caminos disjuntos entre dos nodos
• Si Distancia de Hamming entre dos nodos es K, entonces K de los caminos atraviesan K enlaces
y el resto son de K + 2.
• Diámetro D = log2 N
• El enrutamiento es simple (equivalente a tagged self-routing). El algoritmo que toma la ruta más
corta: Sea P = p1 , . . . , pd el nodo fuente y D = d1 , . . . , dn el destino, entonces los bits en “1” de
P ⊕ R indican la dimensión a escoger como próximo nodo. Ej: tomo siempre el más significativo.
• Hipercubos mapean: anillos (código de Gray); mallas (se agrupan los bits de acuerdo a la dimensión de la malla. Ej: 8→4 × 2⇒b0 b1 b2 →x = b0 b1 , y = b2 ); árboles (se puede construir un
árbol balanceado con dos raı́ces)
El gran inconveniente del hipercubo es la escalabilidad:
• Un hipercubo crece sólo en potencias de 2.
• El número de enlaces por procesador aumenta =⇒limitació fı́sica del procesador.
Para paliar los inconvenientes del hipercubo, se han propuesto variantes (redes jerárquicas) donde cada
nodo del hipercubo consiste en una red de procesadores. Un ejemplo de esto es el Cube Connected
Cycles (CCC), donde cada nodo es un anillo de d procesadores. La idea es aprovechar localidad.
13
MIMD: Esquemas Hı́bridos
[2 clases]
Referencias:
13.1
[NL91, LLG+ 92, Hwa93, Nik93, DT90]
Motivación
Dadas las ventajas y desventajas de cada esquema de MIMD, rápidamente surgió la motivación de combinar
ambos esquemas para obtener lo mejor de cada uno.
• Desde el punto de vista de los SM, el objetivo es resolver el problema de la escalabilidad de la red, y
aliviar el tráfico en la red (disminuir los conflictos).
• Desde el punto de vista de los DM, los objetivos son facilitar la programación y hacerla independiente
de la topologı́a.
En el SM, la solución para aliviar el tráfico de la red es usar cache. Este permite mantener la visión de un
espacio único de memoria. El problema de la escalabilidad de la red es más difı́cil de atacar. Una solución
es hacer clusters de procesadores compartiendo memoria local, y unidos por alguna red a la memoria global.
Con este esquema jerárquico, puede haber crecimiento sin necesidad de afectar a la red entre clusters.
En DM, la solución consiste en una combinación de HW y SW para dar una visión de espacio único de
memoria. En este caso, la memoria global está distribuida entre las memorias locales, con posibilidad de
replicación, lo cual las hace ver como caches.
Los esquemas resultantes puden ser:
• Una memoria principal y caches distribuidos
• No memoria única principal, sino distribuida, con visión de espacio único
• Igual a la anterior, pero con caches locales además de memoria principal
• MIMD/DM con software
Estas soluciones hacen que ambos esquemas se confundan, dando origen a máquinas llamadas Virtual
Shared Memory, Distributed Shared Memory o NUMA (Non-Uniform Memory Access machines).
En ambos casos, se plantea la necesidad de resolver el problema de la coherencia de caches o variable
compartida. Para mantener la coherencia del cache se debe:
1. Si al leer una variable del cache se produce una falla de cache, debe buscarse el último valor. Si existe
memoria global, y ésta está actualizada, se toma de allı́. Sino, debe interrogarse todos los demás caches
para saber quién lo tiene.
2. Al escribir una variable compartida, se debe invalidar las copias en el resto de los caches. Si existe
memoria global debe actualizarse.
El impacto sobre el desempeño de escribir es mayor que el de leer, ya que después de la primera lectura,
las siguientes lecturas producen aciertos.
Solución trivial 1: No permitir que variables compartidas entren al cache (ej: un determinado rango de
localidades en memoria virtual que son inamovibles o usando versiones especiales de LOAD y STORE que
bypasseen el cache). Esta solución es utilizada pero implica un mal desempeño, ya que deben accesarse en
exclusión mutua. En DM, implica tener sólo una copia de cada variable, lo cuál equivale al esquema puro.
Solución 2: Control de coherencia estático.
Consiste en dividir datos en
• privados. Son cargados en sus respectivos caches.
• compartidos. Se dividen a su vez en:
– Read-only o no modificables: pueden cargarse en los caches.
– Modificables o r/w: no entran al cache, la única copia es en memoria principal.
Es factible en aquellos casos donde pueda realizarse esta clasificación. Sin embargo, su rigidez implica pobre
desempeño en muchos otros casos, ya que hay que atravesar la red para accesar la variable.
Solución 3: Control de coherencia dinámico.
Una actualización consiste en:
1. Buscar caches con copia del dato e invalidarlos
2. Inhabilitar caches (lock for exclusive access)
3. Modificar valor
13.2
Implementación de coherencia dinámica
La coherencia implica que cuando se modifique un valor en el cache, se invalide las otras copias. Existen dos
métodos de implementar esto:
• si se dispone de un medio broadcast económico, tal como el bus, usar snoopy cache. Esta es la forma
clásica de implementar caches coherentes en sistemas multiprocesadores sobre un bus. El problema
con este método es que solo puede utilizarse en sistemas unids por bus, y que interfiere ciclos de otros
procesadores.
Existen protocolos “estándars” para manejar la consistencia de los caches a través de un medio broadcast, tales como el MESI (Modifief, Exclusive, Shared, Invalid) o Illinois Protocol. Este comprende los
diferentes estados de un bloque del cache y las acciones que deben tomarse en cada caso.
• Directorio general, que contiene, para cada bloque de memoria, apuntadores a los procesadores o nodos
que poseen una copia. De esta manera, cuando haya que invalidarlas, se enviará la orden de invalidar
solo a los nodos que poseen copia. Hay varias formas de implementar este directorio: centralizado o
distribuido. Puede convertirse en cuello de botella si centralizado, además de ser menos escalable, pero
más eficiente si SM.
Otras alternativas dinámicas
Invalidar al escribir: Al obtener una variable para escritura, divulga un cache-invalidate a otros caches.
Actualizar al escribir: Al obtener var, divulga su nuevo valor a todos los demás caches; los que lo tengan,
actualizan.
Cargar al escribir: Idem que anterior, salvo que todos los caches cargan el nuevo valor.
En principio, las alternativas van de mayor a menor eficiencia, salvo en el caso de programar una barrera,
ya que todos necesitan el valor.
El problema principal, aparte de la coherencia, es el de la latencia en accesos remotos.
Espacio de direcciones. [NL91] Dos aspectos relacionados con el espacio de direcciones deben ser enfrentados por los diseñdores de sistemas:
• ¿Lineal o estructurado (objetos, tuplas, ...) ?
• Grano: desde word (HW) hasta página (SW). Depende de la latencia de la arquitectura. A mayor
latencia, mayor grano. Un mayor grano provoca “false sharing”, mayor tráfico, etc. La tendencia es
dar soporte en HW para disminuri el grano.
13.3
Sistemas basados en directorios
Existen diferentes tipos de directorios, de acuerdo a como implementan el manejo de la información. En
todos los casos, seconsidera que cada procesador se agrega con una cantidad igual de memoria M o de bloques
K, donde K es M dividido por el tamaño del bloque.
Full-map. Por cada bloque contienen:
• una entrada (apuntador o bit) por nodo. Esta entrada será diferente de cero si existe una copia
del bloque en ese nodo.
• un bit “Dirty”. Se coloca en 1 cuando uno de los nodos tiene acceso en escritura. En ese caso
todos los otros nodos tienen en 0 su apuntador.
El cache mantiene dos bits de estado por bloque: 1 bit de válido y otro queindica si puede o no ser
escrito. Estos bits de estado deben ser consistentes con el directorio.
El full-map cubre la posibilidad que haya una copia de un bloque en todos los nodos. El tamaño del
directorio es:
KN entradas, cada uno de tamaño O(N ) (una entrada por procesador). Esto implica que
Tamaño del directorio = O(N 2 )
El inconveniente de este esquema es que el tamaño crece cuadraticamente con el número de procesadores, además del problema de que la estructura crece con N. Todo esto atenta contra la escalabilidad
de este esquema.
Limited. La idea es limitar el número de procesadores que pueden tener simultaneamente copia de un
bloque. Si hay más solicitudes que número de copias máximo, una de las entradas deberá invalidarse
(se escoge una vı́ctima o eviction). Funciona como un set-associative cache de pointers.
Si hay “processor locality”, es decir, que el worker set (número de procesadores activamente usando
un bloque) es menor que el número máximo de copias, funcionará bien. Sino, habrá thrashing.
En este caso, el tamaño se reduce. Como el número de entradas es constante y los apuntadores se
codifican en binario (para representar N procesadores se requieren log2 N bits), entonces el tamaño de
cada entrada es una constante por log2 N , en conclusión
Tamaño del directorio = O(N log2 N )
El inconveniente de este método es que puede caer en thrashing. Alewife implementa una versión
extendida de este esquema (LIMITLESS): Cuando se solicitan más copias que el máximo, esto causa
un trap y se maneja por SW. De esta manera el caso frecuente se maneja de manera óptima (por HW)
y el caso raro se contempla pra evitar thrashing.
Chained lists. Implementa la estructura como una lista encadenada (o doblemente encadenada). En el
directorio se encuentra un apuntador al último que solicitó copia del cache. Cada vez que un nodo
solicita copia, el directorio le pasa el apuntador al anterior y registra su dirección. Cuando hay que
invalidar, el directorio envia la orden de invalidar al nodo que tiene registrado, y este a su vez invalida
y pasa la orden al siguiente, etc. El último (primero que solicitó copia) registra un apuntador a nulo.
Este esquema es altamente escalable, pero tiene un gran costo en tiempo.
13.3.1
Directorios centralizados vs distribuidos
Los directorios centralizados poseenla virtud de asegurar eficazmente consistencias secuencial (ver más adelante), ya que serializan los accesos compartidos. Para accesar en escritura un dato, hay que obtener primero
el acceso en exclusión mutua. Un ente centralizado naturalmente hace esto. Sin embargo, este es un cuello de
botella potencial, que genera alto tráfico sobre la red, además de conflictos (todos quieren accesar el mismo
elemento) y contención. En consecuencia, para lograr escalabilidad, no basta con distribuir la memoria sino
también hay que distribuir el directorio.
Por otro lado los directorios distribuidos tienden a desperdiciar memoria por duplicación de información.
Además, necesitan incorporar mecanismos distribuidos de exclusión mutua para garantizar acceso en exclusión mutua, invalidaciones, etc. Una forma utilizada es manejar la idea del “propietario” de un bloque.
De esta manera, ese nodo se encarga de manejar los accesos a ese bloque (ver DASH). En algunos sistemas,
este propietario puede cambiar (ver KSR-1).
13.4
Latencia en accesos remotos
Las siguientes técnicas se emplean para atacar el problema de la latencia:
Técnicas para tolerar la latencia. Estas se refieren basicamente a como reducir la diferencia entre una
carga local y una carga remota. Entre estas tenemos uso de redes de alta velocidad, aceleramiento
del tiempo de acceso a la cola de mensajes, agrupamiento de accesos remotos para reducir el overhead
global, etc. Otra forma es jugar con el tamaño del bloque. Pero si es muy grande puede provicar “flase
sharing”, es decir, que el bloque incluye dos datos que son accesador por diferentes procesadores pero,
como cayeron en el mismo bloque, son tratados como si estuvieran siendo compartidos.
Técnicas para esconder la latencia. La idea es evitar que la penalización por accesos remotos se refleje
en el desempeño. Entre estas tenemos:
1. Modelos de consistencia relajados
2. Pre-fetching
3. Multi-threading
13.4.1
Modelos de consistencia relajados
Existe una jerarquı́a de consistencia en paralelismo. En un programa secuencial, la consistencia se expresa
como que el valor que devuelve una lectura es el último escrito.
En el primer nivel está el modelo más restrictivo (Lamport), de consistencia secuencial. Es el que surgirı́a
de ejecutar enun solo procesador concurrentemente. Lo que se obtiene es que las operaciones globales pueden
ordenarse totalmente en el tiempo.
En el segundo nivel están los modelos de “processor consistency” y “weak consistency”. Processor consistency significa que desde el punto de vista de las operaciones de uno de los procesadores, son secuecialmente
consistentes (los writes de un procesador son vistos en orden, aunque entrelazados con los de otros procesadores). El modelo de weak cons. no impone ningún orden en las operaciones, pero provee de ciertas
operaciones que se garantizan secuentially consistent. En el tercer nivel está la release consistency, que es
un weak cosnsitency con dos operadores (acquire y release) que son processor consistent.
El nivel superior implica menor concurrencia pero mayor facilidad para el programdor/sisterma para
manejar la consistencia (exclusión mutua, etc.). A medida que bajamos, aumenta la concurrencia, es decir,
el desempeño en el uso de recursos paralelos, pero complica el manejo de consistencia. DASH implementa
release consistency.
13.4.2
Prefetching
Prefetching consiste en traer un bloque a un nodo antes de referenciarlo. Se logrará beneficio si se gana
tiempo en el acceso. Se perderá si el bloque es invalidado antes de usarse o si no se usa (por ejemplo, porque
habı́a un salto condicional). La conistencia debe ser mantenida, es decir, que los bloques prefetched deben
chequearse que no han sido reescritos antes de usarse. En el mejor de los casos el dato estará en el cache
para el momento de usarse.
Sin embargo, producen beneficios en el desempeño (ver DASH o Hwang).
13.4.3
Multithreading
Tener varios threads en cada procesadro puede causar que toda la latencia sea escondida, a codnidción de
tener suficientes threads y que el precio sea bajo (cambio de contexto). Esto permite solucionar el problema
del remote load y casi del synchornizing load (según Nikhil) a condición qu ese maneje el match de las cargas.
La idea es cambiar de contexto cuando hay un cache miss. El efecto del multithreading es bastante
importante como demuestran los resulados en Hwang 93.
13.5
Problemas de la asincronı́a
La asincronı́a produce basicamente dos problemas, según Nikhil.
• Remote Loads. Se quiere hacer dos remotes loads (de A y B, en nodos diferentes para calcular en otro
nodo. Solicita el primero, y luego, envı́a el segundo antes de recibir el primero? Si lo hace, como hacer
el matching cuando empiecen a llegar? En otras palabras, cómo manejar varios eventos pendientes?
• Synchronizing Loads. Mismo problema que antes. Cómo saber cuándo los valores han sido ya producidos? Si semáforos, entonces busy-waiting? o si rendez-vous, cuándo lo hace?
13.6
Soporte para Sistemas Operativos
La nueva tecnologı́a RISC no ha tomado en cuenta los requerimientos de las nuevas verisones de UNIX-like
SO, y no son raros los workloads en los cuales 50 % de ref. a memoria fueron causados por el SO. La Tendencia
para SO basados en UNIX es de implementarse como conjunot de procesos servidores, conunpequeño kernel
replicado (eg: MACH, Chorus) que se comunican mediante pasaje de mensajes. Esto dá máxima flexibilidad
resp. a ambientes paralelos/distribuidos =⇒requerimientos especiales de comunicación de procesos.
• Requerimientos especiales respecto a comunicación entre máquinas: al invocar RPCs, sorprendentemente el t. de com. es apenas el 17% del tiempo del RPC en SRC.
• RISC no ayudan a rebajar overhead de traps y llamadas al sistema (piense en interrupts y pipelining).
Por ejemplo, muchos lightweight RPC para lograr un system call, requiere entrar y salir del kernel 2
veces,lo cual es costoso en salvadas de contexto (eg: Motorola 88000 tiene 5 pipelines).
• Por otro lado, el i860 y el MIPS R2000 por ejemplo tienen un sólo interrupt vector handler, lo cual
agrega ciclos para determinar donde ir.
• Copiar parámetros de un nivel a otro en un RPC o system call implica que además puede afectar
negativamente wrtite-thru caches.
• Manejo de fallas de memoria (page faults).
– En el 88000, un page fault congela la ejecución de FP pipe, pero como este también realiza
operaciones enteras, cuando es rehabilitado puede alterar registros, por lo cual necesita guardar
previamente todos los registros.
– El i860 debe,por razones similares, guardar el estado de los pipes; si el FP estaba usandose, se
agregan 60 instrucciones más por page fault handling.
– Otros procesadores, como SPARC, RS6000, tienen instrucciones precisas para evitar esto.
• Otra falla es pérdida de interrupciones en algunos RISC. Por ej: el i860 no provee la dirección de la
causa de falla, sólo la dirección dela instr. que la causa. Esto implica cerca de 26 instr. para manejar
el trap.
Comentario de AT: no sorprende que mucha gente (eg: Liverpool Par. Library Project] rechace las
soluciones de SO para máquinas paralelas como demasiado pesadas re efectos en desempeño.
Comentario de Stone:
• muy poco se sabe hoy sobre lospatrones comunes de acceso a datos compartidos en multiprocesadores,
porlo tanto todo protocolo de coherencia es digno de consideración en el futuro inmediato.
• Para multiprocesamiento masivo con 100 o 1000 procesadores, la coherencia del cache puede no ser
factible as implementar si tiene que satisfacer las necsidades de sincro. y compartimiento normal.
13.7
Casos
13.7.1
DASH
Proyecto realizado en Stanford para implementar distributed shared memory. Consiste en un conjunto de
“clusters” interconectados por una red de interconexión. Cada cluster posee:
• Un conjunto de procesadores (4 Silicon Graphics), con dos niveles de cache (primer nivel: 1 palabara
cada dos ciclos, segundo nivel: 1 cada 30 ciclos sincronizado con el bus a 16 MHz) . Los caches de
segundo nivel están conectados por un bus con un snoopy protocol.
• Una memoria principal. La memoria global del sistema está dividida entre los clusters.
• Un directorio, que maneja los accesos remotos, y dá servicio de los accesos a la memoria del cluster y
los datos locally cached.
Directorio. IMplementa un full-map (1 bit por cluster), pero disminuido ya que solo guarda un apuntador
por cluster en lugar de por procesador. Cada bloque de memoria tiene un home cluster, quien se encarga
del manejo del acceso a dicho bloque. Cada directorio posee entradas para los bloques que le pertenecen, lo
cual evita que haya duplicacion. EL home cluster se determina por la direccion fı́sica del bloque.
El directorio maneja tres estados para un bloque:
• uncached: not cached by any cluster
• shared: in an unmodified state in the caches of one or more clusters
• dirty: modified in a single cache of some cluster
Protocolo de acceso. Cuando hay un cache-miss del 1er nivel de cache, se busca en el segundo. Si no
está en el segundo se emite una solicitud al bus local por si está en otro cache local. Si está, se realiza una
transferencia rápida de cache a cache. Sino, el directorio captura el requerimiento y, sino está en su memoria
local, envı́a la solicitud al home cluster del bloque.
Cuando un home cluster recibe una sooicitud, chequea el estado del bloque. Sie está limpio lo toma de
la memoria y lo envı́a. Si no está limpio pero está local, fuerza un update y envı́a después. Si está sucio
remoto, envı́a una solicitud al cluster remoto; éste localiza el dato y envı́a el nuevo valor simultaneamente
al solicitante y al home cluster.
Prototipo. La red de interconexión está compuesta por dos wormhole-routed grid de 4x4 clusters (máximo,
64 procesadores). Uno de los grids es para las solicitudes y el otro para la respuesta. Los grids son de 16
bits wide.
13.7.2
Alewife
Un mesh con un SPARC LE (sparc modificado) por nodo, con LIMITLESS directory. Se basa en multithreading para esconder la latencia. El cambio de contexto se hace en 14 ticks. Cada nodo posee 64KBytes
de direct-mapped cahche y 4 MBYTEs compartida. Los nodos (hasta 64) están interconectados por un
wormhole routed mesh de dos dimensiones.
13.7.3
KSR-1
Basado en la idea de que todo es cache (ALLCACHE(TM)) o “cache-only memory” (COMA). Consiste en
una red jeráquica de dos niveles. En el nivel bajo hay anillos de 32 procesadores unidos enun slotted ring a
1Gbyte/s. Estos anillos se llaman SE:0.
Otro anillo SE:1 conecta hasta 34 anillos SE:0, lo caul dá un máximo de 1088 procesadores. Cada
procesador tiene un sub-cache de 0.5MBytes y un cache local de 32 Mbytes.
No hay un “nodo ppropietario o home” para un dato. El propietario de un bloque cambia constantemente.
Provee consistencia secuecnial
14
Subsistema de Entrada/Salida:
[1 clase]: Fotocopiar H y P: 513, 517, 532, (event. 539-546)
EL subsistema de E/S ha sido a menudo despreciado por los constructores de super-computadores, lo
cual ha llevado a una situación donde la tecnologı́a para CPU y memoria crece rapidamente y la de E/S se
rezaga. Esto provoca una tendencia a convertir la E/S en el cuello de botella del sistema. La excepción es
IBM.
Terminologı́a: el subsistema de E/S posee una organización jerárqica. Los siguientes elementos son a
menudo referenciados:
Procesador de E/S: En sistemas de alto desempeño, el sistema es enriquecido con un co-procesador que
se encarga de la E/S, para ası́ permitir al CPU la mayor libertad para ocuparse de los cálculos. Cuando
el CPU encuentre una instrucción de E/S, esta es pasada al procesador de E/S.
Controlador: son dispositivos asociados a un periférico especı́fico de E/S (cinta, terminal gráfico, disco,
etc.), que interpretan las órdenes de E/S y la traducen en comandos de bajo nivel para controlar el
periférico.
Canal: este término, acuñado por IBM, designa las vı́as de comunicación entre el sistema compuesto por el
CPU-Procesador de E/S y los controladores de E/S.
A veces, el procesador de E/S es inexistente y sólo existen interfaces simples entre el bus del CPU y los
canales. Algunas de estas interfaces generalizadas son: para sistemas baratos, el SCSI; y para sistemas de
alto desempeño, el HIPPI (High-Performance Parallel Interface). Para acelerar accesos a discos, se usan disk
o file caches. Estos pueden ser parte de la mem. ppal o funcionar como buffer aparte.
14.1
Esquema tı́pico de dispositivos de E/S
La latencia y el thruput de un sistema de E/S puede verse limitado por cualquier parte del camino entre el
dispositivo y mem. principal, i.e.:
• El dispositivo mismo
• El controlador de E/S
• El bus de mem. y E/S
• La mem. ppal
• El CPU o procesador de E/S (velocidad de atender interrupción)
• Velocidad del software/firmware menjador de E/S
• Eficiencia del uso en el manejo del dispositivo.
¿Cómo medimos desempeño del subsistema de E/S?
14.1.1
Caracterización de la carga de E/S
Supercomputadores: Dominado por accesos en disco a grandes archivos. Generalmente una gran lectura
inicial. Luego muchas escrituras periódicas (para checkpoints) =⇒dominado por escrituras.
CPU
CACHE
Bus de Mem. y E/S
Mem.
Ppal
Control.
E/S
Control.
E/S
Disco Disco
Gráficos
Control.
E/S
Red
Figure 2: Esquema tı́pico de dispositivos de E/S
Procesamiento de transacciones (e.g. banca): Involucra muchos cambios a informaciones compartidas
desde muchos terminales, más alta confiabilidad. Los requerimientos son en varios órdenes:
• Alta rata de transacciones y tiempo de respuesta corto (95% < 1 s.)
• alta disponibilidad13 más extensibilidad modular más simple de usar y administr
• extensibilidad modular
• simple de usar y administrar
TP-1 es un benchmark que simula ATM (cajeros automáticos) y mide respecto al número de transacciones
de déb/cred. por seg. Cada acceso a disco es corto =⇒benchmark accesa de a 100 bytes por seg. Cada
transacción requiere entre 2 y 10 accesos a disco y entre 5000 y 20000 instrucciones de CPU. En general, los
accesos son al azar (no hay patrones o stride),pero hay grandes porciones de la BD que no se referencian (la
mayorı́a de los accesos, alrededor del 80%, es al 20% de la data).
Estaciones de trabajo UNIX: muchos archivos, abiertos por cortos perı́odos, la mayorı́a se borra o
cambia en tiempo corto (ver H y P). Una estación de trabajo para ingenierı́a de 1 MIPS reuqiere 2.5 a 10
KByte/s. Para mediados de 90 se estiman estaciones de 100 MIPS con req. 100 veces mayor.
Resultados de Ousterhout:
• 80% de accesos a discos eran a archivos pequeños (¡ 10KB)
• 90% de todos los acesos eran secuenciales
• 67% de lecturas, 27% escrituras, 6% R/W.
13 Tiempo
promedio entre fallas (MTBF) de componentes simples de 10000 h =⇒99% disponibilidad
Aplicaciones de tiempo real: entre estas citemos las siguientes.
• Procesamiento de imágenes por satélite: los datos llegan a ratas de 7-10 MB/s
• Video y HDTV: imagen enpantalla de 1000x1000 pixels, 3 bytes/pixel, 30 veces por segundo =⇒90
MB/s sostenido. Con menos resolución o con compresión puede bajar a alrededor de 20 MB/s.
• Broadband ISDN: rata de datos de un usuario final es de 75 MB/s en recepción y de 18.75 MB/s
envı́os.
En todas estas aplicaciones es claro que la capacidad de un sólo disco es sobrepasada, lo cual lleva a
utilizar arreglos de discos.
Resultados de un cuestionario de uso de sistemas con Transputers [Eck90] (PUMA, Siemens).
• Tipos de aplicaciones:
– Computational fluid dynamics
– QCD
– Ecuaciones de Einstein
– Proc. de imágenes
• E/S manejada por host
• Checkpointing como carga supercomp. Data swapping por proces. de imágenes
• Accesos secuenciales
• Patrón de E/S vs. computación: fases de E/S-Computación-E/S-Comp-... . Solapamiento posible
• Multitasking (en un nodo) sólo en una aplicación (consecuencia de madurez de plataforma ?)
• Espacio de disco usdo: 76KB a 10 GB
• Entre 1 y 5 archivospor aplicación, excepto QCD (50)
• Transferencias de 10-100 bloques, de 104 a 105 bytes.
14.2
Benchmarks en el mundo de E/S
Pueden dividirse en dos clases [CP93]): aplicaciones y sintéticos.
14.2.1
Aplicaciones
1. Andrew: diseñado en Carnegie-Mellon para comparar el File system de Andrew con otros file system. Se
convirtió en un estándard de facto. Modela la carga generada por un conjunto tı́pico de desarrolladores
de SW: copia un sub-directorio, examina y lee la nueva copia, y luego compila la copia. El sub-directorio
contiene 70 archivos con 0.2MB.
2. TPC-B: (Realizado por el Transaction Processing PErformance Council ). La primera versión se llamó
TP-1 (1985) y se convirtió en el estándard de facto para transacciones. TPC-A y TPC-B reemplazan a
TP-1. Simula operaciones de Débito/Crédito. La métrica utilizada es thruput máximo en transacciones
por segundo, calificado por un umbral de tiempo de respuesta que exige que el 90% de todas las
transacciones se complete en 2 segundos. También reporta precio y almacenamiento requerido.
3. Sdet: System Performance Evaluation Cooperative (SPEC) publicó un conjunto de benchmarks System
development Multi-tasking (SDM) suite, que mide el desempeño global de un sistema para desarrollo
de software y ambiuente de investigación. COnsiste en dos benchmarks: Sdet y Kenbus. Son muy
similares, salvo en la mezcla. Sdet hace más I/O. Consiste en un conjunto de scripts concurrentes
con comandos de edición, formateo de texto, compilación, creación y borrado de archivos, ası́ como
otras utilitarias de UNIX. Va aumentando el número de scripts concurrentes hasta alcanzar el máximo
thruput del sistema en scripts completados por hora. Sdet reporta este máximo, junot con el gráfico
thruput vs. concurrencia de scripts.
14.2.2
Sintéticos
1. Bonnie: mide desempeño de I/O sobre un archivo para un conjunto de cargas simples. Uno lee ela
archivo caracter por caracter; otro lo escribe caracter po caracter. Otra carga hace accesos secuenciales
por bloques; por último, usa tres procesos haciendo accesos aleatorios. Debe cuidar que el archivo sea
mayor que el cache. Reporta thruput en Kiliobytes por segundos o I/O por segundo, y uso de CPU.
2. I/OStone: se basa en trazas de minis y workstation Unix e IBM mainframes. Usa 400 archivos con un
total de 1MB, leyendo y escribiendo datos en patrones de acceso (realizado por un solo proceso) que
aproximan a los de la traza. Reporta IOStones por segundo.
14.3
Discos
(Ver H y P o cualqier libro de mem. secundaria para detalles)
• Ratas de transferencia tı́picas en 1990: 1 a 3 MB/s
• La transferencia es a menudo solo una pequeña parte del tiempo de acceso, por lo que se desconecta
del bus mientras hace seeking, dando oportunidad a multiplexar varios discos sobre el bus.
• Los discos grandes (mayor diámetro, más capacidda por menso electrónica) y lospequeños (mayor
volumen de ventas) poseen un costo relativo similar, de 3 a 5 $ por MB.
14.4
Arreglo o baterı́a de discos
(Tomado de [KGP89]) Es el equivalente en E/S a la memoria intercalada. El problema es que con N dispositivos mecánicos, la confiabilidad (reliability) se reduce en N =⇒RAID (Redundant Array of Inexpensive
Disks).
14.4.1
Niveles de RAID
Nivel 1: Discos especulares Se utiliza sobre todo por tolerancia a fallas. Se replica el disco en arreglos
=⇒reduce en 50% la capacidad de almacenamiento. Permite lecturas más rápidas (min(Latencia(D1),Latencia(D2)))
o realiza lecturas simultáneas de datos diferentes si el hardware posee suficiente concurrencia, pero las escrituras son más lentas, ya que es el
max(Latencia(D1),Latencia(D2).
Nivel 2: Bit interleaved array con ECC. Permite detectar y corregir errores (tipicamente corrección
de 1 error y detección de dos). Cada bit de una palabra más cada bit de ECC va a un disco propio (de 10
a 40% más discos para Hamming). Es muy caro y generalmente no se requiere Hamming completo, pues el
disco tiene detector independiente de falla. Para la lectura, hay que esperar latencia rotacional de todos los
discos, lo cual puede duplicar el tiempo de acceso esperado.
Nivel 3: Detección de falla por hardware más bit de paridad. Sólo usa bit de paridad y confı́a en el
hecho que el disco detecta si está en problemas. La ventaja es que reduce el overhead, y puede reconstruirse
falla de un error más rapidamente.
Nivel 4: Intercalar bloques en lugar de bits con disco de validación. Los esquemas anteriores no
permiten el acceso concurrente en cada grupo de dsicos. Los accesos son secuenciales. Solo aumenta la rata de
transmisión al costo de mayor latencia por el problema de la sincronzación, lo cuál (salvo el 1) los inhabilita
para transacciones. En el nivel 4, un archivo de un solo bloque podrá accesarse directamente, permitiendonse
incluso acceso concurrente a varios discos, eventualmente sobre archivos diferentes. Al accesar un archivo
en lectura, se lee del disco donde se encuentra el bloque, o concurrentemente si posee más de 1 bloque, y
se lee el disco de paridad. Para escribir, se necesita leer el bloque de data más el bloque de paridad para
luego reescribir ambos. No es necesario accesar a los bloques de otros discos puesto que la paridad puede
geenrarse a partir de los bloques de datos viejo y nuevo y el bloque de paridad.
newparity = (old data xor new data) xor old parity
Este esquema presenta el inconveniente que las escrituras no pueden ser concurrentes ya que el bloque de
paridad debe accesarse en exclusión mutua.
Nivel 5: Paridad decalada para paralelizar escrituras. En este caso el bloque de paridad de dos
bloques consecutivos se encuentra en discos diferentes. De esta manera se permite el acceso concurrente en
escritura. Permite más r/w en paralelo.
Existen productos “RAID-like” en el mercado: Imprimis (4 drives de 51/4 más parity drive), Ciprico
Rimfire 6600 (4+1),etc.
14.4.2
Comparación de niveles de RAID
Los únicos niveles que proveen a la vez buen desempeño en accesos pequeños y grandes son los niveles 1 y 5.
Respecto a la lectura, ambos proveen casi un 100 % de efciencia. Los discos especulares aceptan lectura
concurrente sobre cada disco, por lo tanto no hay penalización. Los de nivel 5, aceptan G+1 lecturas
concurrentes con G+1 accesos.
En escritura, el nivel 1 provee la mitad de la eficiencia, ya que hay que escribir en ambos discos. El
nivel 5, en escritura de archivos grandes (muchos bloques) escribirá G sectores en G + 1 accesos (es decir,
puede calcular la paridad completamente porque posee todos los bloques. No necesita leer primero y luego
escribir). Si solo escribe un bloque, la eficiencia es de 25%, ya que cada escritura implica cuatro accesos (leer
bloques viejos de datos y paridad y escribir los nuevos).
14.5
Caso MIMD: iPSC/2
Procesador dedicado de E/S (hasta 127, conectables a c/nodo procesador). Este puede conectarse a una
interfaz SCSI, o u adaptador VME o MUltibus. Un nodo no conectado directamente a procesador de E/S
debe enviar su pedido por la red.
Los archivos se guardan en forma distribuida. cada bloque de 4KB va a un i/o distinto. Cada nodo
i/o contiene un cache de 2 MB o más. El encabezado de un archivo es guardado en un nodo de E/S para
garantizar consistencia de acceso, pero podrı́a volverse cuello de botella.
Existen técnicas que aprovechen topologı́a hipercubo para distribuir los nodos i/o de manera que cada
nodo tenga cerca un nodo i/o.
14.6
14.6.1
Otros casos
CM-2
Ver info sobre Data Vault en calse SIMD.
14.6.2
CRAY Y-MP C90
El subsistema de E/S del CRAY Y-MP C90 es denominado IOS-E. Puede poseer hasta 8 clusters e interfaces
para dos estaciones de trabajo.
Un I/O cluster consta de:
• 4 procesadores de I/O auxiliares EIOP. Un EIOP controla hasta 24 adaptadores de canal para transferencia de datos desde y hacia los periféricos, y hacia o desde el SSD y el mainframe via los buffers
de canal (4 para cada IOP). La transferencia se hace a través de canales de 200 MB/s.
• Un procesador-multiplexor (IOP MUX), que coordina la comunicación con los IOP.
• 16 buffers de I/O
• 1 LOSP (para control, 20 MB/s)
• 2 HISP
• 16 adaptadores de canal.
El SSD posee desde 128 MWords hasta 2 GWords. El acceso desde el CPU se hace por canales de alta
velocidad de 1800 MB/s (tı́picamente un canal cada dos CPU).
Utiliza discos en arreglos de 9: 8 para 1 byte de data + uno de paridad.
14.7
Misceláneas
Si varios procesadores quieren accesar secuencialmente un archivo, el manejo de apuntadores puede ser
complicado.
Para más referencias ver:
• [RB90] presenta el caso de acceso en paralelo a archivos desde un hipercubo. Muestra un algoritmo
para distribuir “nodos” de I/O en el hipercubo para minimizar número de hops.
• [Cro89] considera el rol de los archivos en sistemas paralelos. Introduce el concepto de archivos paralelos.
15
Máquinas SIMD
Definición: Máquina de múltiples elementos procesadores, pero con una única Unidad de Control para el
conjunto. La UC decodifica y difunde la instrucción a los elementos procesadores. Existe la posibilidad de
inhibir ciertos procesadores para evitar que ejecuten una instrucción dada (masking).
Cada procesador puede tener memoria local o no. Se encuentran las mismas organizaciones PE-Mem que
en MIMD. Hay ejemplos de SIMD cuyos PE (elementos procesadores) operan sobre palabras de varios bits:
ILLIAC IV )(64), BSP (16), GF-11 (576); o sobre 1-bit CM (64K), DAP (hasta 4K), MPP (16K). Hay un
compromiso entre el poder de los procesadores y el # de procesadores.
Motivación:
existen varias razones que motivaron la aparición de este tipo de arquitecturas.
1. Existen aplicaciones, como: procesamiento de imágenes, FFT, parallel sorting, multiplicación de matrices, etc, que se programan de manera conveniente bajo el paradigma SIMD, y por ende pueden
ejecutarse eficientemente en máquinas de ese tipo.
2. Razones económicas: hacer N procesadores con una UC es más barato que N computadores similares.
3. La ejecución sı́ncrona permite hacer comunicaciones eficientes, ya que todos accesan al mismo tiempo
y no hay necesidad de sincronizar. Además, elimina carrera crı́tica y deadlock, lo cual facilita el
debugging.
4. Eficiencia en el uso de memoria de instrucciones.
Los SIMD nacieron para resolver problemas especı́ficos. La idea data del 58, para procesar señales de
radar. Hay dos tipos dentro de SIMD:
• Arreglos de procesadores (array computer): utilizados en aplicaciones numéricas, de búsqueda y reconocimento de patrones, etc.
• Procesadores asociativos: empleados en manejo de base de datos, por ejemplo. Aunque no existen aún
máquinas comerciales de este tipo, a nivel de prototipos de investigación está en boga.
15.1
Arreglos de Procesadores
Parámetros:
podemos señalar los siguientes parámetros de interés.
• El # de procesadores
• El # de bancos de memoria
• La red de comunicación
• Control local
• Control global
La red de comunicación es del tipo de las estudiadas en MIMD. Puede ser fija (ejemplo: ILLIAC IV y
CM-1 en malla, o CM-1, en hipercubo). Los problemas de acceso a la memoria son similares a los de los
computadores vectoriales.
El control puede ser: autónomo, donde cada PE decodifica la isntrucción, e incluso puede poseer control
a nivel de las microinstrucciones; o no-autónomo, donde los POE estáncompletamente regulados por la
unidad central.
15.2
Experiencias en SIMD
Desde el 64 empezaron los primeros prototipos, hasta que en el 72 empezó ILLIAC IV, proyecto de 256 PE que
llego solo hasta 64. ILLIAC estaba pensado para operar sobre matrices y resolver ecuaciones diferenciales.
En 1979 empezó el proyecto de BSP, de Burroughs (participante en ILLIAC), que aspiraba a 512 pero
llegó a 16.
En 1983, el Goddard Aerospace Center comenzó el MPP, una malla de 128x128, para procesamiento de
imágenes.
Pero todas esas iniciativas fueron más bien negativas respecto a las expectativas. MPP sigue vivo, pero
ha consumido un presupuesto exagerado.
En 1985, Danny Hillis montó una compañı́a (Thinking Machines) y sacó su CM-1, primera máquina SIMD
comercial exitosa. Esto relanzó las expectativas sobre SIMD. En 1989 lanzó el CM-2. La nueva versión, el
CM-5, se aleja de los SIMD.
El éxito de las CM llevó a otra compañı́a, MAssPar, a sacar su máquina en 1990. Es una malla de dos
dimensiones de 16K procesadores, donde cada PE se conecta a sus 8 vecinos.
El GF-11 fué creado en IBM, para hacer cálculos en investigación en fı́sica molecular. Reducirı́a un
cálculo que tardarı́a 150 años a 20 Mflops, a 4 meses a 11 GFlops.
15.3
Caso: el CM-2
El CM-2 es un CM-1 con las siguientes mejoras:
• Mejor tecnologı́a. Posee más memoria por PE.
• Acelerador de punto flotante
• Red NEXUS de acceso desde front-end. Permite conectar hasta 4 front-end. Un CM-2 puede dividirse
en 4, 2 o 1 secciones.
Arquitectura del sistema:
• 1 o varios front-end, para desarrollo y debugging, procesamiento serial y generación de macro-instrucciones.
• 1 decodificador: secuenciador que traduce las micro-instrucciones a nano-instrucciones que ejecutan
los PE, una por ciclo.
• Data Vault (bóveda de datos): 10 Gbytes (hasta 20), 25 Mbytes/s sostenido cada uno. Pueden haber
varios por sistema.
• n (16, 32 , 64) procesadores de 1 bit, con su memoria, interconectados en grupos de 16 en un hipercubo
de dimensión 12. Además están conecctados en malla.
Lenguajes: *Lisp, Fortran, sobre PARIS. El paradigma de programación es llamado “Data Parallel Algorithms”. Ver libro de Hillis o
Daniel Hillis and Guy Steele, “Data Parallel Algorithms”, Communications of the ACM, Dec 86.
15.3.1
Procesador
• ALU y latchs
• 64K o 256 K bits de memoria local
• Cuatro flag registers de 1 bit
• Aceleradores de punto flotante opcionales
• Interfaz al enrutador
• Interfaz a la malla NEWS
• Interfaz directa al hipercubo
• Interfaz de I/O.
Un chip de 1 cm2 CMOS de 68 pines, contiene 16 PE. La memoria está compuesta por chips comerciales.
Un acelerador de f.p. es compartido por 32 PE (2 chips).
ALU: Posee tres entradas y 2 salidas (bit-serial ALU). En un ciclo lee dos bits de la memoria y 1 del flag.
Produce dos salidas: una para la memoria y otra para otro flag. Una tercera bandera activa o no el store.
Las operaciones son dadas pro dos tablas (cargadas con una nano-instrucción) de 8 bits cada una: una para
la salida hacia la memoria y la otra para la condición.
Ejemplo: suma de dos k-bit signed integers.
1. Carga el context flag
2. Otro flag se selecciona como carry (vı́a NEWS)
3. K iteraciones: lee un bit de cada operando y el carry, ejecuta la suma y el carry-out es enviado
en el carry flag.
15.3.2
Comunicaciones
• Entre vecinos, vı́a un NEWS. Este es un conmuitador que permite coenctar las salidas de los flags
al norte, este, oeste y sur.
• Entre cualquiera vı́a un enrutador (router)
• Directamente sobre el hipercubo (bypasseando el router)
• Usa daisy chain para arbitrar sobre el uso del router.
Router: El enrutador permite a los 16 PÉs de un nodo conectarse a cualquier otro en cualquier nodo. Un
mensaje está compuesto por una trama de aprox. 64 bits (a confirmar!):
• Data (tı́picamente 32 bits)
• Información de dirección para alcanzar el destino (12 bits para el nodo, + 4 para el PE en la malla).
En cada nodo, “O exclusivo” de la dirección de origen y la dirección de destino (dirección relativa =
12 bits). Cada vez que se envı́a en una dimensión, el “1” se pone en “0”.
• Dirección de retorno (16 bits)
La metodologı́a de enrutamiento es store and forward. En un enrutador, el mensaje recibido debe ser
guardado en memoria y luego enviado. Se hace bit por bit (750 ns por bit).
Cada ciclo se envı́a en una dirección del hipercubo. Esto se hace en secuencia de 12 (1 por dimensión).
Cada ciclo de 12 ciclos de dimensión se llama “petit cycle”, con una duracio’n de ≈ 800 ciclos (12x64 bits)
de 750 ns ⇒600 µs.
Sin tráfico un mensaje tarda max. 1 petit cycle en llegar a su destino. Cuando hay tra’fico, unmensjae
que nopuede avanzar en una dirección porque hay otro de mayor prioridad, debe esperar un petit cycle. Si no
hay espacio de buffers en el enrutador, un mensaje que llega puede ser enviado sobre uno de los enrutadores
libres, aunque lo aleje. SI dos mensajes quieren salir por la misma dirección, pero uno de ellos puede ser
enviado en otra dirección, este será enviado en esa dirección.
15.3.3
I/O
Cada grupo de 8K PE comparte 2 procesadores (canales) de I/O. Cada canal provee 50 Mbytes/s. Un
controlador de I/O trata 8K coo dos bancos de 4K. cada chip de PE tiene una lı́nea de I/O =⇒un banco
puede enviar 256 bits en paralelo. Se pueden conectar controladores o frame buffer a los canales de I/O.
Data Vault: es un dispositivo de almacenamiento masivo de datos del CM. Provee un canal de 25 Mbytes/s
sostenido y una capacidad de hasta 20 GBytes.
• Arreglo de 39 discos
• 64 bits del bus de I/O se dividen en dos de 32 bits. Verifica paridad, agrega 7 bits de ECC y almacena
cada bit en un arreglo diferente.
• Un minicomputador controla y corre un proceso de servidor de archivos.
• El front-end se comunica con el Data Vault vı́a Ethernet. Este chequea y envı́a ack al f-e. Los datos
de la memoria del CM son pasados a los I/O controller, con paridad por byte y colocda en la memoria
de los I/O controller.
References
[ACM92] Special number on supercomputing. Communications of the ACM, August 1992.
[AG89]
George Almasi and Allan Gottlieb. Highly Parallel Computing. The Benjammin/Cummings,
1989.
[Bel89]
Gordon Bell. The future of high performance in science and engineering. Communications of the
ACM, August 1989.
[Bel92]
Gordon Bell. Ultracomputers: a teraflop before its time. Communications of the ACM, August
1992.
[CP93]
Peter Chen and David Patterson. Storage performance — metrics and benchmarks. Proceedings
of the IEEE, 81(8), August 1993.
[Cra91]
Cray Research, Inc., Mn. CRAY Y-MP E Series Functional Description Manual, 1991. Number:
HR-04016-0A.
[Cra92]
Cray Research, Inc., Mn. CRAY Y-MP C90 Functional Description Manual, 1992. Number:
HR-04028.
[Cro89]
Thomas Crokett. File concepts for parallel I/O. In Proceedings of Supercomputing ’89, pages
574–579, 1989.
[DD89]
Jack Dongarra and Ian Duff. Advanced architectures comoputers. Technical Memorandum 57
(Revision 2), Argonne National Laboratory, Il., September 1989.
[DT90]
Michel Dubois and Shreekant Takkar. (special issue on cache architectures in tightly coupled
multiprocessors). IEEE Computer, June 1990.
[Eck90]
Eckardt. Investigation of distributed disk i/o concepts. PUMA Report, August 1990.
[HB84]
Kai Hwang and Fayé Briggs. Computer Architectures and Parallel Processing. McGraw-Hill, 1984.
[Hwa93]
Kai Hwang. Advanced Computer Architectures:
McGraw-Hill, 1993.
Parallelism, Scalability, Programmability.
[KGP89] Randy Katz, Garth Gibson, and David Patterson. Disk system architectures for high performance
computing. Proceedings of the IEEE, 77(12), December 1989.
[LLG+ 92] Daniel Lenoski, James Laudon, Kourosh Gharachorloo, Wolf-Dietrich Weber, Anoop Gupta, John
Hennessy, Mark Horowitz, and Monica Lam. The stanford dash multiprocessor. IEEE Computer,
March 1992.
[Nik93]
Rishiyur Nikhil. Multithreaded architectures. Supercomputing ’93 Tutorial, 1993.
[NL91]
Bill Nitzberg and Virginia Lo. Distibuted shared memory: A survey of issues and algorithms.
IEEE Computer, August 1991.
[PH90]
David Patterson and John Hennessy. Computer Architecture: A Quantitative Approach. Morgan/Kaufmann, 1990.
[RB90]
Reddy and Banerjee. Design, analysis and simulation of i/o architectures for hypercube multiprocessors. IEEE Transactions on Parallel and Distributed System, Abril 1990.
[SC91]
Harold Stone and John Cocke. Computer architectures in the 1990s. IEEE Computer, September
1991.
[Sto90]
Harold S. Stone. High-Performance Computer Architecture. Addison-Wesley, second edition,
1990.
[Wei90]
Weicker. An overview of common benchmarks. Computer, December 1990.