Universidad de Costa Rica
Escuela de Ciencias de la Computación e Informática
San Pedro, Montes de Oca

Prof. Allan Berrocal Rojas
Prof. Jeisson Hidalgo-Céspedes (colaborador)

Evaluación

Recurso Peso Descripción

Carta al estudiante

 — 

Describe las expectativas y responsabilidades del curso

Ejemplos de clase

 — 

Ejemplos de programas realizados durante las lecciones

Material del curso

20%

Material y ejercicios a resolver de forma individual

Quices

20%

En Mediación Virtual

Proyecto01

40%

Servidor web concurrente

Proyecto02

20%

Concurrencia declarativa

Lecciones

Lunes 04 de enero: Paradigmas. Proyecto 01

  1. Paradigmas de programación concurrente y distribuido

  2. Requerimientos del proyecto01

Martes 05 de enero: Git. Linux. Pthreads: hola mundo

  1. Crear un repositorio de Git. Claves SSH

  2. Clonar repositorio de Git. Moverse por los directorios con comandos

  3. Pthreads: POSIX Threads

  4. Linux: Prompt PS1. Configuración .bashrc

  5. Mínimo programa en C. Compilar en línea de comandos. Geany

  6. Crear un thread en Pthreads (parte 1)

  7. Punteros a funciones en C

  8. Punteros a void en C

  9. Crear un thread en Pthreads (parte 2). Procesador de C. Linker. Error estándar

  10. Esperar a que otro thread termine (pthread_join). Preguntas

  11. Git: .gitignore, commit, push

Jueves 07 de enero

  1. Linter para C/C++

  2. Makefiles. PHONY

  3. Hilos a alto nivel. Diagramas de tiempo. Scheduler del sistema operativo

  4. Experimentar con la concurrencia. sleep. Monitor de CPU

  5. Valgrind. Memcheck. Helgrind

  6. Condición de carrera

Viernes 08 de enero

  1. Mutex: metáfora del puente angosto y otras

  2. Exclusión mutua (mutex/candado) en Pthreads

  3. Hilos a bajo nivel. Rastreo de memoria

Lunes 11 de enero

  1. Reglas para memcheck y helgrind en Makefile

  2. Copiar y adaptar ejemplo previo. Variables en Makefiles

  3. Argumentos en línea de comandos

  4. Convertir texto a número (ej.: strtoull)

  5. hello_w: crear w threads. Validar la entrada (argumentos)

  6. Enteros de tamaño fijo, stdint.h, inttypes.h

  7. size_t

  8. Serialización en la creación/espera de threads. Concepto de indeterminismo

  9. Vulnerabilidad: arreglos de longitud variable en la pila

Martes 12 de enero

  1. Repaso. Preguntas de mutex y condición de carrera

  2. Memoria dinámica. Alojamiento estático, automático, dinámico. malloc.

  3. Liberar memoria free(). Variables globales. Prototipos de funciones. Modularización

  4. Modularización: dividir subrutinas. Retorno de códigos de error. Linter y números enteros

  5. Jerarquía de archivos .gitignore

  6. Registros en C (structs)

  7. calloc. Memoria privada para threads

  8. Memoria compartida para threads (diseño)

  9. Memoria compartida para threads (implementación)

Jueves 14 de enero

  1. Obtener la cantidad de CPUs disponibles en la máquina

  2. Medir tiempo de pared (wall time) en C

  3. Paralelismo de tareas vs paralelismo de datos

  4. Descomposición en tareas o datos paralelizables

  5. Concepto de mapeo. Mapeo estático por bloques

  6. Modelo matemático del mapeo por bloques

  7. Actividad de mapeo: duración serial y por bloque

  8. Mapeo cíclico

  9. Mapeo dinámico

  10. Mapeo circular por bloques. Incremento de velocidad (speedup)

Viernes 15 de enero: Espera activa

  1. Comparación de los métodos de mapeo

  2. Imprimir en orden. Espera activa (busy waiting)

  3. Ejecución de la espera activa y sus efectos inaceptables

  4. Evitar el control de concurrencia (con estructuras de datos)

Lunes 18 de enero

  1. Estructuras de datos para evitar el control de concurrencia

  2. Preparación de archivos para hello_ordered_semaphores

  3. Concepto de semáforo

  4. Ordenamiento con semáforos. Biblioteca semaphore.h

  5. Implementación del ejemplo hello_ordered_semaphores

Repaso temas de progra1/progra2:

  1. Pruebas de caja negra

  2. px. wget. PATH. history. .bashrc. icdiff

  3. Documentación de código con Doxygen

  4. Buenas prácticas de programación

Martes 19 de enero

  1. Destruir semáforos (para hello_ordered_semaphores)

  2. Variables en Makefiles

  3. Análisis del problema productor-consumidor de buffer acotado

  4. Makefile: Detectar el nombre del ejecutable. Generar .gitignore

  5. Análisis de argumentos. Convertir textos en números con sscanf

  6. Implementación del productor-consumidor sin control de concurrencia

  7. Uso de dos semáforos para controlar la concurrencia del productor-consumidor

Jueves 21 de enero

  1. Espera pseudo-aleatoria. Programación defensiva (assert)

  2. Anaĺisis productor-consumidor de buffer no acotado. Análisis de argumentos

  3. Crear hilos productores y consumidores

  4. Diseño solución al problema. try-wait en un semáforo

  5. Implementación de los productores

  6. Implementación de la cola no thread-safe

Viernes 22 de enero

  1. Clúster del arenal. Tarea03. Topología de un clúster

  2. Detener los consumidores. Es break/continue/return buena práctica?

  3. Implementación de los consumidores

  4. Cola thread-safe. Efectos de control de concurrencia incorrecto

  5. Tarea03: algunos comentarios

Lunes 25 de enero: rastreo de procesamiento

  1. Preparación para el rastreo de procesamiento

  2. Simplificaciones y supuestos para el rastreo

  3. Rastreo de procesamiento (productor-consumidor no acotado con error)

Martes 26 de enero

  1. Pregunta: crear más hilos que unidades de trabajo?

  2. Pregunta: se puede crear una jerarquía de hilos?

  3. Diseño: detener los consumidores tras terminar el trabajo

  4. Implementación: detener los consumidores tras terminar el trabajo

Jueves 28 de enero: reentrant, thread-safe, modularización

  1. Generador lineal congruencial (rand)

  2. Subrutina reentrante vs thread-safe

  3. Hacer el código reentrante y thread-safe

  4. Modularización de código (.c .h). Variables automáticas en Makefiles. Include guards

Viernes 29 de enero: profiling, callgrind, Amdahl

  1. Analizar (lint) varios fuentes en el Makefile

  2. Taxonomía de herramientas de análisis estático y dinámico. Profiling

  3. Análisis de instrucciones/invocaciones con Callgrind. Visualización con KCachegrind

  4. Git: ignorar la salida de Callgrind

  5. Optimización en el proceso de resolución de problemas. Método sugerido para optimizar. Sobre-optimización

  6. Métrica de eficiencia

  7. Ley de Amdahl (el speedup está acotado por la porción serial del programa)

Martes 16 de febrero: Sincronización. OpenMP

  1. Solución alternativa a formar agua (parte gráfica)

  2. Solución alternativa a formar agua (algoritmo)

  3. Problema de fumadores de cigarrillos

  4. Concurrencia declarativa

  5. OpenMP: Open Multi-Processing. Hola mundo en OpenMP. Directivas

Jueves 18 de febrero: OpenMP

  1. Cómo funciona OpenMP internamente

  2. Región paralela. Equipo de hilos (thread team)

  3. Número de hilo, cantidad de hilos en la región. OpenMP y Valgrind

  4. Paso de variables: default(none), shared, private

  5. Repartir iteraciones creando hilos: omp parallel for

  6. Repartir iteraciones sin crear hilos: omp for

  7. Reflexión sobre la tecnología OpenMP y la disciplina

  8. Descomposición y mapeo de iteraciones en OpenMP: schedule

  9. Análisis espacio-temporal de algoritmos paralelos

Viernes 19 de febrero: MPI

  1. El paradigma de programación distribuida

  2. Message Passing Interface (MPI). OpenMPI. MPICH

  3. Hola mundo en MPI. Compilar (mpic++). mpiexec. Procesos vs hilos

Lunes 22 de febrero: MPI

  1. Repaso de MPI

  2. Ejecución de MPI en clúster. sshfs. hosts.txt

  3. Número de proceso (rank). Cantidad de procesos (size). Hostname

Jueves 25 de febrero: MPI

  1. Matener una conexión SSH activa

  2. Medir tiempo de pared con Linux perf (instalación)

  3. Medir el tiempo de pared con MPI

  4. Comunicación colectiva en MPI. Broadcast

  5. Números pseudoaleatorios en C++

  6. Reducciones en MPI

  7. MPI allreduce

  8. Proyecto 01: Fase 3 distribuida

Viernes 26 de febrero: lectores y escritores

  1. Problema de lectores y escritores

  2. Candados de lectura y escritura en Pthreads