Concurrencia en C con hilos POSIX: varias personas programando comparten pocos dongles USB y tienen que compilar antes de agotarse. Es el proyecto de C del rank 03 de 42next y el heredero directo de Philosophers.
fifo o edf) y la obligación de programar tu propia cola de
prioridad. Es decir, del «que no se bloquee» se pasa al «que además sea justo».Un único programa, codexion, que simula la mesa con un hilo por persona y un
hilo monitor aparte, y escribe por la salida un log con marca de tiempo de cada cambio de
estado. La simulación acaba cuando alguien se agota o cuando todo el mundo ha compilado al
menos el número de veces pedido.
Las reglas generales son las de los proyectos de C de siempre: Norma, nada de segfaults ni
double free, sin fugas de memoria, Makefile con $(NAME),
all, clean, fclean y re que no haga
relink, compilando con cc y -Wall -Wextra -Werror -pthread. Y una
específica de este proyecto: las variables globales están prohibidas.
Funciones autorizadas: pthread_create, pthread_join,
pthread_mutex_init, pthread_mutex_lock,
pthread_mutex_unlock, pthread_mutex_destroy,
pthread_cond_init, pthread_cond_wait,
pthread_cond_timedwait, pthread_cond_broadcast,
pthread_cond_destroy, gettimeofday, usleep,
write, malloc, free, printf,
fprintf, strcmp, strlen, atoi y
memset. Fíjate en lo que no está: ni pthread_detach, ni
pthread_cond_signal (solo broadcast), ni semáforos.
No hay parte bonus en el enunciado. Sí hay recode: en la evaluación pueden pedirte una modificación pequeña del proyecto en directo.
Las personas se sientan en círculo, numeradas de 1 a
number_of_coders; la 1 se sienta junto a la última y cada
N entre N - 1 y N + 1. Hay tantos dongles
como personas, uno entre cada dos, y para compilar hay que tener los dos de los lados
a la vez. Si solo hay una persona, sobre la mesa hay un único dongle.
Cada persona repite el ciclo coger dos dongles → compilar → soltarlos → depurar → refactorizar y, al acabar de refactorizar, intenta enseguida volver a coger dongles. Los tres estados se excluyen entre sí. Las personas no se comunican y no saben si otra está a punto de agotarse.
pthread_mutex_t precisamente «para evitar que se
dupliquen dongles». Y el caso de una sola persona con un solo dongle es la trampa clásica de
Philosophers: nunca podrá tener dos, así que la simulación tiene que acabar en burnout en lugar
de quedarse colgada.Ocho argumentos, todos obligatorios:
./codexion number_of_coders time_to_burnout time_to_compile time_to_debug \
time_to_refactor number_of_compiles_required dongle_cooldown scheduler
| Argumento | Significado (según el enunciado) |
|---|---|
number_of_coders | personas, y también dongles |
time_to_burnout | ms: si alguien no empieza a compilar en ese tiempo desde el inicio de su última compilación (o desde el inicio de la simulación), se agota |
time_to_compile | ms compilando, con los dos dongles en la mano |
time_to_debug | ms depurando |
time_to_refactor | ms refactorizando |
number_of_compiles_required | si todo el mundo llega a este número de compilaciones, la simulación se detiene |
dongle_cooldown | ms que un dongle queda no disponible después de soltarlo |
scheduler | exactamente fifo o edf |
Hay que rechazar las entradas no válidas: números negativos, valores que no sean enteros o un planificador distinto de esos dos.
Los únicos mensajes posibles son estos cinco, con el tiempo en milisegundos y el número de la persona:
timestamp_in_ms X has taken a dongle
timestamp_in_ms X is compiling
timestamp_in_ms X is debugging
timestamp_in_ms X is refactoring
timestamp_in_ms X burned out
Dos mensajes nunca pueden mezclarse en una línea, y el de burned out tiene que
salir como mucho 10 ms después del momento real del agotamiento. El enunciado
recomienda gettimeofday() para medir el tiempo.
usleep(200000) no duerme exactamente 200 ms: duerme
al menos eso, y luego el sistema operativo te devuelve la CPU cuando le parece. Con
muchos hilos esos retrasos se acumulan, y es justo lo que puede hacer que el burnout se anuncie
tarde. El margen de 10 ms es la versión medible de «tu programa reacciona a tiempo».Lo que pide la parte obligatoria, punto por punto:
pthread_create;pthread_cond_t) para gestionar las colas de espera;Una variable de condición es la forma de esperar «hasta que pase algo» sin estar preguntando en bucle (espera activa). El patrón general, que viene en cualquier manual de pthreads, es siempre el mismo: se espera dentro de un while que vuelve a comprobar la condición, porque al despertar no hay garantía de que siga cumpliéndose:
pthread_mutex_lock(&m);
while (!condicion)
pthread_cond_wait(&c, &m); /* suelta m, duerme, y lo recupera al despertar */
/* aquí condicion es cierta y tienes m */
pthread_mutex_unlock(&m);
pthread_cond_timedwait hace lo mismo pero con un tiempo límite, algo útil
cuando además de esperar a un recurso tienes un reloj corriendo.
Enfriamiento obligatorio. Cuando alguien suelta un dongle, nadie puede volver a
cogerlo hasta que pasen dongle_cooldown milisegundos.
Arbitraje justo obligatorio. Si varias personas piden el mismo dongle, se concede según el planificador:
fifo (First In, First Out): a quien lo pidió primero;edf (Earliest Deadline First): a quien tenga el plazo de
agotamiento más próximo, con plazo = last_compile_start + time_to_burnout.El enunciado exige que, con edf, nadie se agote siempre que los
parámetros sean viables, y que la planificación se haga con una cola de
prioridad (heap) programada por ti, porque C89 no trae ninguna en su biblioteca
estándar.
Además de lo de siempre (primera línea en cursiva con los logins, secciones de Descripción, Instrucciones y Recursos con el uso de IA), este proyecto pide dos secciones más:
pthread_mutex_t, pthread_cond_t, eventos propios), cómo coordinan
el acceso a dongles, log y estado del monitor, con ejemplos de cómo evitas las condiciones de
carrera.El idioma del README es libre (se recomienda inglés). La convención del usuario de tener un README en cada repo encaja aquí sin esfuerzo extra.
time_to_compile es mayor que time_to_burnout, el agotamiento es
inevitable.burned out, sin colgarse.pthread_cond_broadcast esté autorizada).join de todos los hilos y destruir todos los mutex y
condiciones, tanto si acaba bien como si acaba en burnout. Herramientas útiles para
comprobarlo: valgrind --tool=helgrind o -fsanitize=thread.fifo/edf se rechazan. Ojo con atoi, que no avisa de
nada.El enunciado no está aún en el pack. Esta ficha sale de una transcripción pública del enunciado en castellano (versión 1.0), contrastada con los README de dos entregas de otros estudiantes, que coinciden en argumentos, mensajes, planificadores y cola de prioridad:
No confirmado: si se hace individual o en grupo, y las horas estimadas.