<aside> 💡

Este proyecto no se hizo con heap. Cada dongle tiene su propia cola de prioridad donde solo entran 2 coders(Los dos que van a usar ese dongle).

El subject pedía:

• Se debe implementar una cola de prioridad (heap) para la planificación FIFO/EDF (C89 no tiene una biblioteca estándar para esto).

El heap es una cola de prioridad que se organzia como un arbol binario. Para eso debe hacerse una sola cola para todos los dongles.

</aside>

Codexion es un proyecto de simulación concurrente diseñado para resolver variaciones del problema clasico de Dining Philosophers* aplicado a el entorno de desarrollo de software moderno.

La simulación consiste en un set de coders (hilos) que necesitan ejecutar tareas (Compile, Debug and Refactor). Para compilar, el coder debe contar con 2 dongles (recursos compartidos). El reto principal de este proyecto es gestionar la competencia por estos recursos basandose en una politica de arbitraje (FIFO Y EDF), evitar probelmas de sincronización y diseñar un hilo monitor que puenda detener la simulación ante el agotamiento (burnout).

Conceptos

Este fue el plan de acción que tomé para desarrollar el proyecto:

• 1. Definición de Estructuras y Parsing de Argumentos

Estructuras

• 2. Implementación de Utilidades (Tiempo y Logs)
• 3. El Ciclo de Vida del Programador (Hilos)
• 3.1 Planificación y Estructuras de Datos (FIFO/EDF)
• 4. El Hilo Monitor

Flujo de la simulación

Pruebas de uso

Diagrama:

                ┌────────────────────┐
                │       main()       │
                └─────────┬──────────┘
                          │
                 argc == 9 ?
                ┌─────────┴──────────┐
               NO                    YES
        ┌──────────────┐     ┌──────────────┐
        │ error + exit │     │   parseo     │
        └──────────────┘     └──────┬───────┘
                                     │
                         ┌───────────▼───────────┐
                         │  init desk/coders/    │
                         │       dongles         │
                         └───────────┬───────────┘
                                     │
                         ┌───────────▼───────────┐
                         │ start_simulation()    │
                         └───────────┬───────────┘
                                     │
        ┌────────────────────────────┼────────────────────────────┐
        │                            │                            │
┌───────▼────────┐       ┌──────────▼─────────┐      ┌──────────▼─────────┐
│ coder 1 thread │       │ coder 2 thread     │ ...  │ coder N thread     │
└───────┬────────┘       └──────────┬─────────┘      └──────────┬─────────┘
        │                            │                            │
        │                    (run_coder loop)                    │
        └──────────────┬─────────────┴──────────────┬───────────┘
                       │                            │
                       ▼                            ▼
            ┌──────────────────────┐     ┌──────────────────────┐
            │ monitor thread       │     │ shared state (desk)  │
            └──────────┬───────────┘     └──────────┬───────────┘
                       │                            │
                       └────────────┬──────────────┘
                                    ▼
                          desk->end_simulation

Flujo de los mutex

coder thread
    │
    ▼
LOCK mutex (dongle)
    │
    ▼
pthread_cond_wait
    │
    ├── unlock mutex (TEMPORAL)
    │
    ├── sleep (espera señal)
    │
    └── re-lock mutex al despertar