El trabajo final de teoría forma parte del sistema de evaluación continua de la asignatura. Consiste en la realización y exposición individual de un tema relacionado con la programación concurrente.

Elección del trabajo

• Debes elegir uno de los temas propuestos (de carácter amplio y genérico para que puedas enfocarlo a tu manera).
• Comunica tu elección mediante tutoría en UA-Cloud antes del 30 de septiembre.
• Envía tres propuestas por orden de preferencia para que, en caso de que alguna ya esté asignada, se te pueda adjudicar otra.
• Si no has elegido trabajo antes de esa fecha, se te asignará uno al azar de entre los disponibles, siempre que hayas optado por la evaluación continua.

Entregables

La realización del trabajo incluye dos entregables:

1. Documento escrito

• Entregar un documento en formato PDF.
• Fecha límite: hasta la penúltima clase de teoría del mes de diciembre.
• Se debe entregar el documento en formato PDF y la presentación en formato digital en http://pracdlsi.dlsi.ua.es.
• El documento debe partir de la información inicial (enlaces sugeridos en algunos temas) y ampliarla con tu propia investigación.
• Puedes reservar tutorías para resolver dudas durante la preparación o consultarlas durante el tiempo libre en las sesiones de prácticas.

2. Presentación oral

• Presentación individual de 10 minutos de duración.
• Se realiza en clase durante la última semana lectiva del cuatrimestre (diciembre).

Resumen de fechas importantes

• 30 de septiembre: fecha límite para comunicar la elección de trabajo.
• Penúltima clase de diciembre: fecha límite para entregar el documento escrito.
• Última semana lectiva de diciembre: presentaciones orales en clase.

Listado de temas

(El orden no es relevante.)

• Addressing priority inversion with proxy execution.
• A new futex API.
• Making the Global Interpreter Lock Optional in Python [1]​ y [2]​.
• [oss-security] StackRot (CVE-2023-3269): Linux kernel privilege escalation vulnerability.
• A virtual filesystem locking surprise.
• The atomic_ops library (libatomic_ops).
• The shrinking role of semaphores.
• Concurrencia en Swift/Objective C.
• Concurrencia en C/C++ para Windows.
• Concurrencia con Boost C++ Libraries: Interprocess, Fiber, Thread, Context y Coroutine2.
• Concurrencia en C++ con Qt: Qthreads, QMutex, QAtomic*, QtConcurrent…
• Concurrencia en C++ 11/14/17/20: Multi-threading library.
• Concurrencia en C++: std::atomic library.
• Corrutinas en C++20 y C++23.
• CppCoro es una biblioteca que trata de hacer más sencillo el uso de corrutinas en C++. Explícanos como funciona, que añade nuevo, por qué dice que facilita el uso de corrutinas, etc… Puedes ayudarte de este vídeo y de éste otro artículo.
• Concurrencia en C# .NET.
• Concurrencia en Go: Goroutinas, canales, etc…
• Concurrencia en PHP, Javascript y otros lenguajes de Internet.
• Exclusión mutua a bajo nivel: instrucciones ensamblador y spinlocks básicos.
• Get started with Java’s new structured concurrency model: [1]​ y [2]​.
• Virtual Threads en Java 21+ (Project Loom / JEP 444): Hilos ligeros en espacio de usuario frente a hilos del sistema operativo. [1] y [2].
• Spinlocks avanzados.
• Memoria transaccional.
• Técnicas de detección de condiciones de carrera. Explica el contenido de este artículo.
• Detección de condiciones de carrera en el núcleo del SO. Explica el contenido de este artículo.
• Thread Pools, OpenMP y Grand Central Dispatch.
• Paralelismo con intel TBB.
• Planificación de hilos en arquitecturas híbridas y heterogéneas (Intel P/E-Cores, Apple Silicon, ARM big.LITTLE): [1] y [2].
• Concurrencia en lenguaje Rust: threads, mutex, canales, Arc.
• Rust: Crate Parking Lot y comparación con la biblioteca estándar antes y después de Rust 1.62.
• Concurrencia en rust 1.62: Rust 1.62: Thinner, faster mutexes on Linux.
• Concurrencia en rust 1.63: Rust 1.63: Scoped threads.
• Rust: Paralelismo con rayon.
• Rust: Paralelismo con scoped threadpool y comparación con Rust 1.63.
• Rust: Paralelismo con crossbeam.
• Rust async / await. Comparación con el uso de threads.
• Rust y mejores tiempos de compilación.
• Interface FUTEX de Linux para implementación de bibliotecas concurrentes.
• Rust: explícanos qué es loom, para qué sirve y cómo se usa.
• Explica este fallo en el nucleo linux.
• Linux kernel’s preemption models.
• Linux kernel’s memory barriers.
• Lockless Algorithms. Lockless patterns: full memory barriers. Relaxed access and partial memory barriers. An introduction to compare-and-swap. More read-modify-write operations. Lockless patterns: some final topics. Este trabajo sería para 2 ó 3 personas.
• Lockless slab shrink en el núcleo Linux. Los accesos a datos en exclusión mutua son costosos en cuanto a tiempo, por eso si es posible se prefieren usar algoritmos que no hagan uso de Mutexes, incluso en el núcleo del SO como puedes ver en este artículo.
• N Times Faster Code With Parallel Algorithms. Descarga y compila el código. Explica lo que hace el autor, cómo usa la concurrencia. Trata de añadir tú otras mejoras que hagan uso de concurrencia también.
• Retro voxel engine. Descarga el código, compílalo. Explícanos como funciona, sobre todo la parte de concurrencia.
• Paralelización del entrenamiento de redes neuronales: Data parallelism y model parallelism.
• Distribución de entrenamiento de LLMs en clusters.
• Entrenamiento distribuído de redes neuronales con Horovod.
• Concurrencia en frameworks de Deep Learning.
• Aprovechamiento de CPU y GPU de manera eficiente en el entrenamiento de redes neuronales.
• Concurrencia en la inferencia de Modelos de Lenguaje (LLMs): vLLM, PagedAttention y Continuous Batching para servir múltiples peticiones simultáneas [1] y [2].
• Trazado y monitorización de concurrencia en tiempo real con eBPF en el Kernel de Linux [1] y [2].
• El Modelo de Actores y la Máquina Virtual BEAM (Erlang / Elixir): Concurrencia masiva con paso de mensajes sin memoria compartida [1] y [2].
• Concurrencia y paralelismo masivo en GPU con CUDA y WebGPU [1] y [2].