🚀 Programación Concurrente y Distribuidas en Rust

Colección integral de actividades prácticas y análisis teórico sobre concurrencia, sincronización, modelos de actores, redes de Petri y protocolos distribuidos implementados en Rust.

---

📑 Índice

• 📋 Descripción del Proyecto
• 💡 Funcionalidades Clave
• 📂 Estructura del Repositorio
• 🚀 Instalación y Ejecución
  • Prerrequisitos
  • Instalación
• 🛠️ Tecnologías Utilizadas
• 📄 Licencia

---

📋 Descripción del Proyecto

Este repositorio reúne las soluciones a las actividades prácticas de la asignatura Programación Concurrente de la Facultad de Ingeniería de la Universidad de Buenos Aires (FIUBA).

A lo largo del proyecto se abordan desde los fundamentos de la sintaxis y conceptos del lenguaje Rust (ownership, borrowing, structs, enums, traits, manejo de errores y concurrencia básica) hasta paradigmas avanzados y sistemas distribuidos (sección crítica, atómicos, modelos de actores, asincronía con Tokio, algoritmos de elección de líder Bully/Ring, replicación por quórum, transacciones distribuidas con 2PC y Saga, y modelado formal mediante Redes de Petri).

Todas las soluciones de código están desarrolladas en Rust, garantizando la seguridad en el manejo de memoria y concurrencia mediante los principios de Ownership, Borrow Checker, y los traits Send y Sync.

---

💡 Funcionalidades Clave

• Introducción a Rust (Actividad 1): Modelado de un gestor de tareas explorando ownership, borrowing, la inmutabilidad por defecto, tipos Option y Result, Enums con pattern matching, Traits y la creación de hilos en segundo plano.
• Exclusión Mutua y Sección Crítica (Actividad 2): Demostración de condiciones de carrera mediante bloques unsafe y estudio de algoritmos clásicos (Dekker y Peterson).
• Correctitud Concurrente (Actividad 3): Implementación de un contador atómico lock-free con Arc<AtomicUsize> y ordenamiento de memoria Ordering::SeqCst.
• Mecanismos de Sincronización Asíncrona (Actividad 4): Modelado de una planta embotelladora con semáforos y un motor de renderizado 3D paralelo sincronizado por Barrera Mariposa (Butterfly Barrier).
• Problemas Clásicos de Concurrencia (Actividad 5): Soluciones seguras a Productor-Consumidor (búfer acotado) y el Barbero Dormilón usando Arc, Mutex y Condvar.
• Modelos de Concurrencia (Actividad 6): Procesamiento paralelo Fork-Join con scoped threads, consulta de sensores asíncrona mediante tokio::join! y comunicación MPSC.
• Modelo de Actores (Actividad 7): Simulación de un gestor de cuentas bancarias y transferencias concurrentes libre de deadlocks y condiciones de carrera.
• Concurrencia en Sistemas Distribuidos (Actividad 8): Replicación con quórum (lectura/escritura) y monitoreo de salud mediante señales Heartbeat.
• Algoritmos Distribuidos de Elección (Actividad 9): Implementación de algoritmos de elección de líder Bully y Ring con tolerancia a fallos.
• Transacciones Distribuidas (Actividad 10): Simulación del protocolo Two-Phase Commit (2PC) con recuperación por Write-Ahead Logging (WAL) y análisis del patrón Saga.
• Redes de Petri (Actividad 11): Modelado formal discreto con exploración BFS de estados alcanzables, canales asíncronos en Tokio y detección de bloqueos por colapso de coordinador.

---

📂 Estructura del Repositorio

programacion-concurrente/
├── introduccion_a_rust/                       # Actividad 1: Fundamentos de Rust, Gestor de Tareas, Ownership y Threads
├── seccion_critica_y_exclusion_mutua/        # Actividad 2: Algoritmos de exclusión mutua y condiciones de carrera
├── correctitud_de_programas_concurrentes/    # Actividad 3: Contador atómico lock-free e invariantes
├── mecanismos_de_sincronizacion/              # Actividad 4: Planta embotelladora y Barrera Mariposa 3D
├── problemas_clasicos_de_concurrencia/        # Actividad 5: Productor-Consumidor y Barbero Dormilón
├── modelos_de_concurrencia/                   # Actividad 6: Fork-Join, Async/Await y Canales MPSC
├── modelo_de_actores/                         # Actividad 7: Gestor bancario basado en actores
├── concurrencia_en_sistemas_distribuidos/     # Actividad 8: Quórum de replicación y Heartbeats
├── algoritmos_distribuidos/                   # Actividad 9: Algoritmos de elección Bully y Ring
├── transacciones_distribuidas/                # Actividad 10: Protocolo 2PC con WAL y Patrón Saga
└── redes_de_petri/                            # Actividad 11: Simulación de Redes de Petri y análisis 2PC

---

🚀 Instalación y Ejecución

Prerrequisitos

Para compilar y ejecutar cualquiera de las soluciones, debes contar con el entorno de desarrollo de Rust instalado (compilador rustc y gestor de paquetes cargo). Puedes instalarlo formalmente desde rustup.rs.

Verifica la instalación correcta ejecutando:

rustc --version
cargo --version

Instalación

1. Clonar el repositorio:

   git clone https://github.com/SebaB29/programacion-concurrente.git
   cd programacion-concurrente

💡 Instrucciones de Ejecución: Cada subdirectorio del proyecto cuenta con su propio archivo README.md dedicado, donde se detallan los comandos de ejecución específicos, parámetros disponibles, pruebas unitarias y ejemplos de salida de consola para cada módulo.

---

🛠️ Tecnologías Utilizadas

• Lenguaje principal: Rust (Edición 2021)
• Runtime Asíncrono: Tokio (Soporte para async/await, join!, canales MPSC y semáforos asíncronos)
• Primitivas de Concurrencia Nativa: std::sync::{Arc, Mutex, Condvar, RwLock}, std::sync::atomic::{AtomicUsize, Ordering}, std::thread::spawn
• Paso de Mensajes: Canales std::sync::mpsc, tokio::sync::mpsc y tokio::sync::oneshot
• Herramientas de Compilación y Testing: Cargo, cargo test, cargo clippy, cargo fmt

---

📄 Licencia

Este proyecto fue desarrollado en el marco académico de la materia Programación Concurrente (75.59 / 95.07) de la Facultad de Ingeniería de la Universidad de Buenos Aires (FIUBA). Los derechos pertenecen a los autores del repositorio.