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 la presentación en formato digital (preferiblemente PDF) 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).
• Puedes entregar tantas veces como quieras; solo se corregirá la última entrega.

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]​.
• 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.
• Intel Thread Director. ¿Qué es, cómo funciona, qué aporta? En estos dos enlaces [1]​ y [2]​ tienes acceso a más información.
• Intel Thread Director 2. ¿Qué novedades añade respecto a la generación anterior?
• Concurrencia en lenguaje D: Threads y Fibers.
• Uso Threads, ThreadPools y Métodos asincronos en lenguaje Vala.
• 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.
• Structured Parallel Fortran. ¿Qué es? ¿Qué aporta a la programación concurrente?
• Retro voxel engine. Descarga el código, compílalo. Explícanos como funciona, sobre todo la parte de concurrencia.
• Paralelización de 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.