1. Del catálogo inmutable al dato mutable
El catálogo del tema 25 se construía antes de lanzar lectores y no cambiaba durante las consultas. Sus offsets y longitudes seguían siendo válidos porque nadie modificaba los campos después de la validación.
Ahora cambiamos esa premisa: dos trabajadores quieren registrar que completaron una tarea. Cada uno incrementa un contador común. Compartir la ubicación del contador no establece un turno entre ambos ni convierte el incremento en una transacción.
Para modificar datos compartidos hay que definir qué accesos pueden coincidir, qué operaciones deben ser indivisibles y qué condición autoriza a leer un resultado.
El objetivo del contador es sencillo: si dos trabajadores completan N operaciones cada uno, el total deseado es 2 × N. La pregunta importante no es cuántas veces aparece ese número al ejecutar, sino qué propiedad del programa obliga a conservar las dos contribuciones.
| Diseño | Quién escribe | Cuándo se lee |
|---|---|---|
| Catálogo inmutable. | Un creador durante la preparación. | Después de su terminación exitosa. |
| Contador común sin protección. | Varios trabajadores sobre el mismo objeto. | El padre espera al final, pero los escritores se solapan entre sí. |
| Casillas independientes. | Cada hijo escribe su propia casilla. | El padre suma después de recoger a todos. |
2. Carrera de datos y error de protocolo
Dos accesos son conflictivos si actúan sobre la misma ubicación y al menos uno modifica su contenido. Si procesos que comparten memoria realizan esos accesos sin la coordinación necesaria, no tenemos un programa de comunicación correctamente sincronizado.
No toda coincidencia entre procesos es problemática: varios lectores de un objeto estable pueden consultar al mismo tiempo. También pueden trabajar varios escritores sobre objetos distintos, como las casillas del tema 23.
Conviene distinguir una carrera de datos, donde faltan garantías para los accesos conflictivos, de un error lógico de intercalado, donde cada acceso está ordenado pero la operación completa admite una secuencia que rompe el objetivo.
Por ejemplo, ambos trabajadores pueden guardar una copia antigua del contador y luego escribir resultados derivados de esa copia, aunque un supervisor ordene por separado cada lectura y escritura. El total será incorrecto sin necesitar accesos simultáneos al contador.
No trataremos un programa con escrituras ordinarias concurrentes como si C y POSIX garantizaran todos sus resultados mediante una simple enumeración de turnos. Las reglas del lenguaje, la implementación y la sincronización también importan. El modelo de «leer, sumar, escribir» explica una pérdida posible; no es una especificación completa de una carrera real.
3. Un incremento tiene varias acciones
contador++;
/* Para razonar sobre la actualizacion:
1. obtener el valor anterior;
2. calcular anterior + 1;
3. reemplazar el contador con ese resultado. */La forma exacta de las instrucciones depende del compilador y la arquitectura. Lo esencial es que una expresión ordinaria de incremento no adquiere, por su sintaxis, un contrato de actualización atómica entre procesos.
| Paso | Proceso A | Proceso B | Contador |
|---|---|---|---|
| Inicial. | Sin copia. | Sin copia. | 0. |
| 1. | Lee 0 en su copia local. | — | 0. |
| 2. | — | Lee 0 en su copia local. | 0. |
| 3. | Escribe su copia + 1. | — | 1. |
| 4. | — | Escribe su copia + 1. | 1. |
Hubo dos intenciones de incrementar y dos escrituras, pero el valor final es uno. La segunda escritura no incorpora el cambio de la primera. A esto lo llamamos actualización perdida.
Si A completa su lectura y escritura antes de que B lea, B parte de uno y termina dejando dos. El cambio de orden altera el resultado. Un diseño correcto para el contador debe excluir el primer intercalado o reemplazar la operación por otra que conserve ambas contribuciones.
Una sola CPU también puede alternar procesos entre las acciones de una operación lógica. La ejecución paralela en varios núcleos puede ampliar las oportunidades de solapamiento, pero no es un requisito para que exista este problema.
4. Compartición, atomicidad y orden
| Propiedad | Pregunta que responde | Lo que no basta |
|---|---|---|
| Almacenamiento compartido. | ¿Los procesos acceden al mismo objeto? | MAP_SHARED no protege sus modificaciones. |
| Atomicidad de una operación. | ¿Puede intercalarse otra operación dentro de ella? | Que una carga o almacenamiento sea indivisible no hace indivisible leer y modificar. |
| Orden y publicación. | ¿Qué escrituras deben preceder a qué lecturas? | Escribir una bandera ordinaria al final no establece por sí solo el protocolo. |
| Exclusión mutua. | ¿Quién puede ejecutar la sección crítica? | Proteger solo la escritura final deja lecturas antiguas fuera de la protección. |
| Finalización. | ¿Ya terminaron todos los participantes? | Esperarlos al final no ordena retroactivamente sus incrementos. |
El contrato de mmap describe la compartición de cambios, según mmap(2). No ofrece un bloqueo por cada campo C ni un mecanismo de reserva de turnos para actualizar una estructura.
La coherencia de caché tampoco transforma una secuencia de operaciones en una sección crítica. Incluso imaginando que cada proceso ve perfectamente el último almacenamiento, dos cálculos pueden haberse basado ya en la misma copia anterior.
5. Dos experimentos con objetivos distintos
Separaremos una demostración determinista del mecanismo lógico y una observación deliberadamente incorrecta de accesos concurrentes. Así podremos reproducir una pérdida sin atribuir garantías falsas al programa con carrera.
| Programa | Qué controla | Qué permite concluir |
|---|---|---|
| intercalado26. | El padre ordena cada lectura y escritura mediante tuberías y confirmaciones. | Una copia antigua puede sobrescribir una actualización aunque los accesos individuales estén ordenados. |
| carrera26 sin_proteccion. | Solo prepara la región, libera el arranque y recoge hijos. | Permite observar síntomas en ese entorno; no define un resultado portable del contador. |
| carrera26 casillas. | Cada hijo tiene una salida propia y el padre espera antes de leer. | Ofrece un total esperado comprobable con el protocolo por fases. |
Los dos programas usan una región anónima compartida creada antes de fork. No hacen falta nombres para estudiar el acceso a los campos. Todos los participantes ejecutan el mismo binario y heredan las mismas definiciones de tipos.
La diferencia entre solapado y serie del primer programa no depende de sleep. El padre espera una confirmación antes de ordenar la siguiente acción. Las tuberías transportan control; el valor del contador permanece en la región compartida.
6. Código de apoyo para procesos y tuberías
Guarda esta cabecera como apoyo26.h. Incluye validación numérica, operaciones de un byte y recolección de hijos. Las transferencias de control comprueban EINTR, EOF y fallos de escritura.
#ifndef APOYO26_H
#define APOYO26_H
#define _DEFAULT_SOURCE
#include <errno.h>
#include <inttypes.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
static inline int numero(const char *s, uint32_t maximo, uint32_t *n)
{
if (!*s) return -1;
for (const char *p = s; *p; ++p)
if (*p < '0' || *p > '9') return -1;
errno = 0;
char *fin;
unsigned long x = strtoul(s, &fin, 10);
if (errno || *fin || x == 0 || x > maximo) return -1;
*n = (uint32_t)x;
return 0;
}
/* Retorna 1 al recibir, 0 en EOF y -1 al fallar. */
static inline int recibir(int fd, unsigned char *c)
{
ssize_t n;
do { n = read(fd, c, 1); } while (n == -1 && errno == EINTR);
return n == 1 ? 1 : n == 0 ? 0 : -1;
}
static inline int enviar(int fd, unsigned char c)
{
ssize_t n;
do { n = write(fd, &c, 1); } while (n == -1 && errno == EINTR);
return n == 1 ? 0 : -1;
}
static inline int cerrar(int *fd)
{
if (*fd == -1) return 0;
int r = close(*fd);
*fd = -1;
if (r == -1) perror("close");
return r;
}
static inline int esperar(pid_t pid)
{
int estado;
pid_t r;
do { r = waitpid(pid, &estado, 0); } while (r == -1 && errno == EINTR);
if (r == -1) { perror("waitpid"); return -1; }
if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
fprintf(stderr, "Fallo del hijo %ld\n", (long)pid);
return -1;
}
return 0;
}
static inline int preparar_senales(void)
{
struct sigaction a;
memset(&a, 0, sizeof a);
a.sa_handler = SIG_IGN;
if (sigemptyset(&a.sa_mask) == -1 || sigaction(SIGPIPE, &a, NULL) == -1) {
perror("configurar SIGPIPE");
return -1;
}
return 0;
}
#endifSe ignora SIGPIPE para que una escritura sin lector pueda informar EPIPE y seguir la ruta de limpieza. Esa política se establece antes de fork y la heredan los hijos. No se utilizan manejadores para tocar la memoria compartida.
La función cerrar invalida el entero después del intento, evitando un segundo cierre de un número que Linux podría haber liberado. Los programas son independientes, de un solo hilo antes de fork, y no tienen otro recolector de hijos compitiendo con esperar.
7. Programa: ordenar lecturas y escrituras
Guarda intercalado26.c. Hay dos trabajadores, cada uno con una tubería de órdenes y otra de confirmaciones. R captura el contador en una variable local; W escribe esa copia más uno. El padre decide el orden y no envía el siguiente paso hasta recibir K.
En el modo solapado ordena R de A, R de B, W de A y W de B. En serie ordena R de A, W de A, R de B y W de B. La unidad lógica «incrementar» sigue dividida, aunque cada acceso al contador esté coordinado.
#include "apoyo26.h"
static int trabajar(int entrada, int salida, uint32_t *contador)
{
uint32_t copia = 0;
int tiene_copia = 0;
unsigned char orden;
int r;
while ((r = recibir(entrada, &orden)) == 1) {
if (orden == 'R' && !tiene_copia) {
copia = *contador;
tiene_copia = 1;
} else if (orden == 'W' && tiene_copia) {
*contador = copia + 1;
tiene_copia = 0;
} else {
return 2;
}
if (enviar(salida, 'K') == -1) return 3;
}
return r == 0 && !tiene_copia ? 0 : 4;
}
static int paso(int orden, int aviso, unsigned char accion)
{
unsigned char respuesta;
if (enviar(orden, accion) == -1) {
perror("enviar orden");
return -1;
}
if (recibir(aviso, &respuesta) != 1 || respuesta != 'K') {
fprintf(stderr, "Falta confirmacion del trabajador\n");
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
uint32_t rondas;
if (argc != 3 || (strcmp(argv[1], "solapado") != 0 &&
strcmp(argv[1], "serie") != 0) ||
numero(argv[2], 1000, &rondas) == -1) {
fprintf(stderr, "Uso: %s solapado|serie rondas(1..1000)\n", argv[0]);
return EXIT_FAILURE;
}
if (preparar_senales() == -1) return EXIT_FAILURE;
uint32_t *contador = mmap(NULL, sizeof *contador, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (contador == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
*contador = 0;
int orden[2][2] = {{-1, -1}, {-1, -1}};
int aviso[2][2] = {{-1, -1}, {-1, -1}};
pid_t pids[2];
int creados = 0, fallo = 0, completo = 0;
int solapado = strcmp(argv[1], "solapado") == 0;
for (int i = 0; i < 2; ++i) {
if (pipe(orden[i]) == -1 || pipe(aviso[i]) == -1) {
perror("pipe"); fallo = 1; goto limpiar;
}
}
for (int i = 0; i < 2; ++i) {
pid_t pid = fork();
if (pid == -1) { perror("fork"); fallo = 1; goto limpiar; }
if (pid == 0) {
int entrada = orden[i][0], salida = aviso[i][1];
for (int j = 0; j < 2; ++j) {
cerrar(&orden[j][1]); cerrar(&aviso[j][0]);
if (j != i) { cerrar(&orden[j][0]); cerrar(&aviso[j][1]); }
}
int codigo = trabajar(entrada, salida, contador);
if (cerrar(&entrada) == -1 || cerrar(&salida) == -1) codigo = 5;
if (munmap(contador, sizeof *contador) == -1) codigo = 6;
_exit(codigo);
}
pids[creados++] = pid;
}
for (int i = 0; i < 2; ++i) {
if (cerrar(&orden[i][0]) == -1 || cerrar(&aviso[i][1]) == -1) {
fallo = 1; goto limpiar;
}
}
for (uint32_t n = 0; n < rondas; ++n) {
int indices[4] = {0, solapado ? 1 : 0, solapado ? 0 : 1, 1};
const char *acciones = solapado ? "RRWW" : "RWRW";
for (int k = 0; k < 4; ++k) {
int i = indices[k];
if (paso(orden[i][1], aviso[i][0], (unsigned char)acciones[k]) == -1) {
fallo = 1; goto limpiar;
}
}
}
completo = 1;
limpiar:
/* Cerrar ordenes libera por EOF a hijos que esperan mas trabajo. */
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
if (cerrar(&orden[i][j]) == -1) fallo = 1;
if (cerrar(&aviso[i][j]) == -1) fallo = 1;
}
}
for (int i = 0; i < creados; ++i)
if (esperar(pids[i]) == -1) fallo = 1;
if (completo && !fallo) {
uint32_t esperado = solapado ? rondas : 2 * rondas;
printf("Orden: %s\nIntentos de incrementar: %" PRIu32 "\n",
argv[1], 2 * rondas);
printf("Valor final: %" PRIu32 "\nEsperado para este orden: %" PRIu32 "\n",
*contador, esperado);
if (*contador != esperado) fallo = 1;
}
if (munmap(contador, sizeof *contador) == -1) { perror("munmap"); fallo = 1; }
return fallo || !completo ? EXIT_FAILURE : EXIT_SUCCESS;
}Las confirmaciones enlazan la acción terminada con la siguiente orden. El padre no lee el contador durante el trabajo y espera a todos antes de imprimir. No necesitamos volatile para este experimento: el orden se expresa mediante IPC.
Las tuberías no vuelven atómica la operación lógica completa porque el protocolo permite que ambos trabajadores conserven una copia antes de escribir. La documentación de la interfaz de tuberías está en pipe(2).
8. Comparar un orden solapado y uno serial
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic intercalado26.c -o intercalado26
$ ./intercalado26 solapado 10
Orden: solapado
Intentos de incrementar: 20
Valor final: 10
Esperado para este orden: 10
$ ./intercalado26 serie 10
Orden: serie
Intentos de incrementar: 20
Valor final: 20
Esperado para este orden: 20En solapado se pierde una contribución por ronda: ambos leen el mismo valor inicial y ambos escriben ese valor más uno. En serie, cada trabajador lee después de la escritura anterior. Las dos salidas están definidas por sus protocolos y se pueden comprobar.
El retorno cero de solapado significa que el modelo produjo el resultado previsto para ese orden; no significa que el contador cumpla el objetivo de registrar los veinte intentos. El programa demuestra un fallo de diseño reproducible.
El nombre solapado describe que las dos operaciones lógicas de lectura-modificación-escritura se intercalan. Los accesos concretos al contador siguen ordenados por el padre. No hay una carrera de datos deliberada en este primer programa.
9. Programa: contador sin protección y casillas
Guarda carrera26.c. Dos hijos esperan un byte de arranque y luego realizan entre una y cinco millones de iteraciones cada uno. El padre no imprime ni consulta la región hasta recogerlos.
En sin_proteccion ambos modifican un contador volatile sin exclusión. Es un experimento intencionalmente incorrecto para Linux con GCC, no una técnica de IPC válida. En casillas cada uno acumula en una variable privada y publica solamente en su posición al terminar.
#include "apoyo26.h"
struct region {
volatile uint32_t contador;
uint64_t casilla[2];
};
int main(int argc, char **argv)
{
uint32_t iteraciones;
if (argc != 3 || (strcmp(argv[1], "sin_proteccion") != 0 &&
strcmp(argv[1], "casillas") != 0) ||
numero(argv[2], 5000000, &iteraciones) == -1) {
fprintf(stderr, "Uso: %s sin_proteccion|casillas iteraciones(1..5000000)\n",
argv[0]);
return EXIT_FAILURE;
}
int casillas = strcmp(argv[1], "casillas") == 0;
if (preparar_senales() == -1) return EXIT_FAILURE;
struct region *r = mmap(NULL, sizeof *r, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) { perror("mmap"); return EXIT_FAILURE; }
r->contador = 0;
r->casilla[0] = 0;
r->casilla[1] = 0;
int inicio[2] = {-1, -1};
pid_t pids[2];
int creados = 0, fallo = 0;
if (pipe(inicio) == -1) { perror("pipe"); fallo = 1; goto limpiar; }
for (int i = 0; i < 2; ++i) {
pid_t pid = fork();
if (pid == -1) { perror("fork"); fallo = 1; goto limpiar; }
if (pid == 0) {
cerrar(&inicio[1]);
unsigned char token;
if (recibir(inicio[0], &token) != 1 || token != 'I') _exit(2);
if (cerrar(&inicio[0]) == -1) _exit(3);
if (casillas) {
uint64_t local = 0;
for (uint32_t k = 0; k < iteraciones; ++k) ++local;
r->casilla[i] = local;
} else {
/* Deliberadamente incorrecto: dos escritores sin proteccion. */
for (uint32_t k = 0; k < iteraciones; ++k) {
uint32_t copia = r->contador;
r->contador = copia + 1;
}
}
if (munmap(r, sizeof *r) == -1) _exit(4);
_exit(0);
}
pids[creados++] = pid;
}
if (cerrar(&inicio[0]) == -1) { fallo = 1; goto limpiar; }
for (int i = 0; i < 2; ++i) {
if (enviar(inicio[1], 'I') == -1) {
perror("enviar arranque"); fallo = 1; goto limpiar;
}
}
limpiar:
/* Si fallo un fork antes de liberar el arranque, los hijos reciben EOF. */
if (cerrar(&inicio[0]) == -1) fallo = 1;
if (cerrar(&inicio[1]) == -1) fallo = 1;
for (int i = 0; i < creados; ++i)
if (esperar(pids[i]) == -1) fallo = 1;
if (!fallo && creados == 2) {
uint64_t objetivo = UINT64_C(2) * iteraciones;
printf("Modo: %s\nObjetivo de la aplicacion: %" PRIu64 "\n",
argv[1], objetivo);
if (casillas) {
uint64_t total = r->casilla[0] + r->casilla[1];
printf("Casillas: %" PRIu64 " y %" PRIu64 "\nTotal: %" PRIu64 "\n",
r->casilla[0], r->casilla[1], total);
if (r->casilla[0] != iteraciones || r->casilla[1] != iteraciones ||
total != objetivo) fallo = 1;
} else {
printf("Observado: %" PRIu32 "\n", r->contador);
puts("Experimento sin proteccion: este numero no prueba correccion.");
}
}
if (munmap(r, sizeof *r) == -1) { perror("munmap"); fallo = 1; }
return fallo || creados != 2 ? EXIT_FAILURE : EXIT_SUCCESS;
}La tubería de arranque reduce la ventaja del primer hijo mientras se crea el segundo, pero no garantiza que ejecuten simultáneamente ni en qué CPU lo harán. Una vez enviado un token, ese hijo puede avanzar antes de que el otro reciba el suyo.
El intervalo numérico elegido evita que el objetivo de diez millones desborde uint32_t y que las sumas correctas desborden uint64_t. Esos límites no corrigen la carrera de sin_proteccion.
El retorno cero en sin_proteccion indica que se completó el experimento y se recogieron los hijos sin detectar errores de control. No valida el contador. En casillas, además se comprueban las dos contribuciones y el total.
10. Observar el contador sin exigir un resultado fijo
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic carrera26.c -o carrera26
$ ./carrera26 sin_proteccion 1000000
Modo: sin_proteccion
Objetivo de la aplicacion: 2000000
Observado: ...
Experimento sin proteccion: este numero no prueba correccion.
$ for prueba in 1 2 3 4 5; do ./carrera26 sin_proteccion 1000000; doneLos puntos suspensivos representan una observación de tu ejecución. Puede aparecer un valor distinto del objetivo o incluso el objetivo. No establecemos una cifra, un porcentaje de pérdida ni una frecuencia mínima de fallo.
Si aparecen dos millones, no has demostrado ausencia de carrera. Es posible que los procesos apenas se hayan solapado o que las circunstancias de esa ejecución hayan ocultado el síntoma. El programa sigue sin una operación que proteja la lectura-modificación-escritura.
Si aparece un valor diferente, has observado una anomalía en ese binario y entorno. No extrapoles una ley portable como «siempre queda entre N y 2N»: el programa incorrectamente sincronizado no ofrece ese contrato.
El experimento no es un test que deba fallar para pasar. Una comprobación automática del curso no debe exigir que sin_proteccion produzca menos que el objetivo. La demostración reproducible de pérdida ya está en intercalado26.
11. Por qué las casillas sí tienen un contrato
$ ./carrera26 casillas 1000000
Modo: casillas
Objetivo de la aplicacion: 2000000
Casillas: 1000000 y 1000000
Total: 2000000Cada hijo acumula en una variable privada. Después escribe solamente casilla[i]. Ningún otro hijo escribe ese elemento y el padre no lee los elementos mientras los hijos pueden modificarlos.
Que dos elementos estén en la misma página o línea de caché no los convierte en el mismo objeto C. Puede haber efectos de rendimiento por compartir una línea, pero las responsabilidades de escritura siguen separadas.
Con -O2 el compilador puede simplificar la acumulación local porque su resultado es conocido. Eso no rompe el contrato del ejemplo. Tampoco permite usar esta comparación como un benchmark justo de contadores: las dos variantes realizan trabajos de máquina muy diferentes.
La reducción por casillas sirve cuando el padre puede esperar hasta el final. Si necesita un total actualizado durante el trabajo o varios consumidores deben retirar elementos, habrá que diseñar la coordinación correspondiente.
12. Qué hace y qué no hace volatile
El contador incorrecto se declaró volatile para facilitar observar accesos repetidos en el experimento con GCC. Esa decisión impide tratarlo como un acumulador privado ordinario que pudiera mantenerse sin accesos observables al objeto según las reglas de esa implementación.
No establece exclusión mutua, no convierte la secuencia de carga y almacenamiento en una actualización atómica y no publica automáticamente otros campos. GCC documenta que los accesos no volatile no quedan ordenados respecto de los volatile en su documentación sobre volatile.
/* Este fragmento NO es un protocolo de publicacion valido. */
datos->resultado = 49;
datos->lista = 1; /* aunque lista se haya declarado volatile */
/* Otro proceso no obtiene la coordinacion necesaria solo por hacer: */
while (!datos->lista) { }
printf("%d\n", datos->resultado);Al quitar volatile podrías ver otro comportamiento generado por el compilador. Al añadirlo no has reparado la sincronización. Compilar sin optimización tampoco constituye una protección del dato.
La lección no es convertir todos los campos compartidos en volatile. Es escoger un protocolo y mecanismos que expresen las garantías necesarias entre participantes.
13. Esperas, banderas y publicación de resultados
waitpid permite esperar y recoger el estado de un hijo. El padre de los ejemplos comprueba su terminación antes de consumir las salidas, de acuerdo con wait(2). Eso ordena la lectura final respecto del trabajo terminado de ese hijo.
Sin embargo, el padre puede esperar correctamente a dos hijos que se hayan sobrescrito durante su ejecución. La finalización no transforma sus incrementos anteriores en operaciones indivisibles ni reconstruye una contribución perdida.
| Técnica | Qué aporta | Qué falta para un contador concurrente |
|---|---|---|
| waitpid al final. | Esperar la terminación y comprobar su estado. | Coordinar entre sí a los escritores durante el trabajo. |
| Tubería de arranque. | Evitar que un hijo empiece antes de recibir permiso. | Proteger cada actualización posterior. |
| sleep o sched_yield. | Cambiar oportunidades de planificación. | Una condición de corrección verificable. |
| msync. | Controlar actualización del archivo respaldante cuando corresponda. | Exclusión y publicación de la estructura entre procesos. |
| Bandera ordinaria. | Representar un estado del formato. | Operaciones adecuadas para comunicar y observar ese estado. |
En intercalado26, la tubería no se usa solo al comenzar: cada acción tiene una confirmación. En carrera26 solo hay un permiso inicial. Esa diferencia de protocolo explica por qué el primer programa tiene un orden preciso y el segundo no protege las actualizaciones.
Una barrera que obligara a ambos a comenzar la ronda juntos tampoco haría atómico el incremento. Incluso podría facilitar que ambos obtuvieran el mismo valor anterior. Hay que proteger la operación apropiada, no únicamente reunir a los procesos.
14. Qué debe proteger la sincronización
Si eliges exclusión mutua, la sección crítica debe incluir la lectura del valor que se va a modificar y la escritura del resultado. Leer fuera de la protección y proteger solo el almacenamiento final conserva el problema de las copias antiguas.
entrar_en_seccion_critica();
anterior = contador;
contador = anterior + 1;
salir_de_seccion_critica();| Estrategia | Idea | Condiciones que deben respetarse |
|---|---|---|
| Semáforo usado para exclusión. | Un participante entra y devuelve el permiso al salir. | Mismo recurso de coordinación, inicialización correcta y tratamiento de errores. |
| Mutex entre procesos. | Proteger la sección crítica completa. | Ubicación compartida y configuración para procesos; recuperación definida. |
| Actualización atómica apropiada. | Una operación de lectura-modificación-escritura con el contrato requerido. | Soporte entre procesos y alineación de la implementación; orden de memoria acorde al protocolo. |
| Casillas y reducción. | Evitar varios escritores sobre el mismo dato. | Propiedad de cada salida y lectura posterior coordinada. |
| Propietario único con mensajes. | Un proceso actualiza el contador al recibir contribuciones. | Entrega, validación, capacidad y cierre del canal. |
Usar operaciones atómicas no significa que cualquier combinación de ellas represente un incremento indivisible. Una carga atómica seguida de un almacenamiento atómico sigue siendo dos operaciones; para conservar contribuciones se necesita la actualización adecuada o un protocolo completo.
No incorporaremos un supuesto arreglo con _Atomic sin especificar sus garantías entre procesos. Tampoco basta copiar un mutex privado al área compartida. En el siguiente bloque estudiaremos semáforos POSIX como un mecanismo explícito de coordinación, comenzando con nombres y ciclo de vida.
La recuperación ante una caída dentro de la sección crítica es otro requisito. Un permiso no vuelve automáticamente porque el proceso que debía devolverlo haya muerto. La exclusión no sustituye el diseño de fallos del servicio.
15. Optimización, trazas y herramientas
Comparar compilaciones sin convertirlo en una prueba de corrección
$ gcc -std=c17 -O0 -Wall -Wextra -Wpedantic carrera26.c -o carrera26_O0
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic carrera26.c -o carrera26_O2
$ ./carrera26_O0 sin_proteccion 1000000
$ ./carrera26_O2 sin_proteccion 1000000
$ ./carrera26_O2 casillas 1000000La optimización cambia el código y sus tiempos. También influyen la carga del equipo, los núcleos disponibles y la planificación. Esas variables pueden cambiar la observación, pero no añaden una sección crítica donde no existe.
Leer la traza de control
$ strace -f -e trace=read,write,close,clone,fork,vfork,wait4 ./intercalado26 solapado 1La traza permite seguir bytes R, W y K, cierres y esperas. Los accesos al contador son instrucciones de memoria y no aparecen como llamadas read o write al canal. Las escrituras de texto de stdout también figuran en la traza, pero no coordinan a los hijos.
Añadir printf dentro de un bucle puede alterar bastante su planificación. Un fallo que deja de verse al registrar cada paso no queda reparado. En el modelo controlado usamos mensajes de protocolo para ordenar; en el experimento libre evitamos impresiones de los hijos.
Comprender el alcance de los detectores
AddressSanitizer y UndefinedBehaviorSanitizer sirven para clases de errores de memoria y operaciones inválidas que instrumentan; no convierten un contador sin protección en correcto. ThreadSanitizer instrumenta detección de carreras, según las opciones de instrumentación de GCC.
No supongas que un detector mantiene un historial común de accesos de procesos distintos creados con fork y una región compartida. Su soporte depende de la herramienta y del patrón; una ejecución sin aviso no certifica este diseño entre procesos. El análisis de propiedad y orden sigue siendo necesario.
16. Explorar el intercalado paso a paso
El modelo comienza con contador cero. Cada trabajador realiza una lectura, un cálculo privado y una escritura. Puedes avanzar A y B por separado o cargar un orden completo. La opción con exclusión conserva la propiedad de la sección crítica hasta que su dueño escribe.
Contador compartido0
Trabajador AAntes de leer; sin copia
Trabajador BAntes de leer; sin copia
Exclusión y finalizaciónSin exclusión; 0 de 2 actualizaciones terminadas
Avanza A y B hasta que ambos hayan leído cero.
«Orden de pérdida» intenta avanzar A y B alternadamente. Sin exclusión ambos conservan cero antes de escribir y el final es uno. Con exclusión, B debe esperar a A, y el mismo intento de alternar termina conservando ambas contribuciones.
El simulador es un modelo secuencial de operaciones lógicas. No ejecuta una carrera del lenguaje ni simula cachés, compiladores o todas las conductas posibles de un programa sin sincronización. Su función es explicar qué parte de la operación debe protegerse.
17. Pruebas, errores y limpieza
Contratos que sí se pueden comprobar
$ ./intercalado26 solapado 1
... valor final 1 para dos intentos ...
$ ./intercalado26 serie 1000
... valor final 2000 para dos mil intentos ...
$ ./carrera26 casillas 1
... casillas 1 y 1; total 2 ...
$ ./carrera26 casillas 5000000
... casillas 5000000 y 5000000; total 10000000 ...Comprueba también que cero, negativos, texto no numérico, cantidades fuera de rango y modos desconocidos se rechazan antes de reservar recursos. Ninguna prueba del contador libre debe exigir que aparezca una diferencia concreta.
Rutas de fallo controladas
- Segundo fork fallido. Simula el fallo en una copia. Los hijos ya creados deben salir al cerrarse las órdenes o el arranque, y el padre debe recogerlos.
- Trabajador fallido. En intercalado26 inserta _exit(7) al comienzo de una rama hija. El padre debe detectar EPIPE o la falta de confirmación y limpiar al otro trabajador.
- Orden inválida. En una variante de prueba envía W sin una lectura pendiente. El trabajador debe rechazar la secuencia, no escribir una copia inventada.
- Fin parcial. Interrumpe una ronda controlada tras la lectura. El trabajador puede descartar su copia al detectar el cierre y terminar con error; no se informa un resultado válido.
| Recurso o estado | Responsabilidad | Condición de limpieza |
|---|---|---|
| Región compartida anónima. | Cada proceso tiene una vista. | munmap local; no existe nombre que retirar. |
| Órdenes y confirmaciones. | Cada rol conserva solo sus extremos. | Cerrar copias sobrantes permite que EOF tenga significado. |
| Hijos creados parcialmente. | El padre conserva sus PID. | Cerrar canales de trabajo y recoger todos los creados. |
| Datos de salida. | El padre decide si la ejecución es aceptable. | Solo consumirlos después de esperas y controles de éxito. |
Los bucles son finitos y los protocolos de control no envían un volumen de respuestas que llene las tuberías. No incorporan un plazo global: un hijo detenido externamente puede mantener al padre esperando. Un supervisor de servicio necesitaría detección, cancelación y recolección con su propio contrato.
Si el padre muere de forma abrupta, las reglas de EOF y EPIPE ayudan a terminar a trabajadores que usan los canales. No prometen resolver cualquier caída o suspensión. La variante libre, una vez arrancada, termina su cálculo finito antes de salir.
18. Resumen
- Compartir memoria no establece exclusión ni hace atómicas las operaciones ordinarias.
- Un incremento combina obtener un valor, calcular y reemplazarlo.
- Dos copias antiguas pueden producir una actualización perdida.
- El intercalado controlado demuestra un error lógico con accesos individuales ordenados.
- El contador sin protección es un experimento incorrecto, sin resultado numérico portable.
- Observar el objetivo muchas veces no demuestra ausencia de carrera.
- volatile no es un bloqueo, una operación de incremento atómico ni una publicación de estructuras.
- Esperar hijos al final no recupera contribuciones sobrescritas durante el trabajo.
- Una sección crítica debe cubrir la operación lógica completa.
- Un escritor por casilla y una reducción posterior evitan compartir el mismo contador mutable.
- Las herramientas y la instrumentación tienen un alcance que debe comprobarse.
- El siguiente bloque aportará semáforos para coordinar participantes explícitamente.
19. Preguntas de repaso y práctica
Responde antes de desplegar la explicación. Distingue las garantías del modelo de las observaciones del programa incorrecto.
1. ¿MAP_SHARED convierte contador++ en una actualización atómica?
No. Comparte el almacenamiento, pero no protege la secuencia lógica de obtener, modificar y reemplazar el valor.
2. ¿Cómo pueden dos incrementos dejar un resultado igual a uno?
Si ambos parten de una copia de cero y cada uno escribe su copia más uno. La segunda escritura conserva uno y no incorpora la contribución anterior.
3. ¿El experimento solapado tiene una carrera de datos deliberada?
No. Cada acceso se ordena mediante órdenes y confirmaciones. El error está en permitir que las dos operaciones lógicas conserven una copia antigua antes de escribir.
4. ¿Qué demuestra el modo serie del primer programa?
Que completar lectura y escritura de A antes de permitir la lectura de B conserva ambas contribuciones en cada ronda.
5. ¿Se necesitan dos núcleos para una actualización perdida?
No. Un planificador puede alternar procesos entre las acciones de una operación lógica incluso cuando solo hay una CPU disponible.
6. ¿Dos millones en sin_proteccion prueba que el contador es correcto?
No. Es una observación de ese binario y ejecución. El diseño no incorpora la coordinación que garantice conservar todas las contribuciones.
7. ¿Por qué no se exige que el experimento libre pierda incrementos?
Porque no se garantiza una frecuencia de fallo ni un valor final. El entorno puede ocultar el síntoma; la pérdida reproducible se estudia con el protocolo controlado.
8. ¿Qué aporta volatile en el experimento con GCC?
Facilita mantener accesos observables al contador según las reglas de la implementación. No añade exclusión, atomicidad del incremento ni publicación de otros datos.
9. ¿waitpid al final protege los incrementos de los hijos?
No. Permite al padre esperar la finalización antes de leer. Los hijos pueden haberse sobrescrito entre sí antes de esa espera.
10. ¿Proteger solo la escritura final es suficiente?
No. Dos participantes pueden leer el mismo valor fuera de la protección y luego escribir resultados basados en él. La sección debe cubrir la lectura-modificación-escritura completa.
11. ¿Por qué las casillas no necesitan un bloqueo para cada suma local?
La suma local pertenece a un proceso, cada salida tiene un único escritor y el padre lee después de recoger a todos. Se evita el conflicto sobre un mismo contador.
12. ¿Una tubería de arranque garantiza ejecución simultánea?
No. Concede permiso para comenzar; el planificador decide cuándo ejecuta cada hijo. No ordena los accesos posteriores.
13. ¿Una carga atómica seguida de un almacenamiento atómico equivale a incrementar atómicamente?
No. Son dos operaciones separadas y otro participante puede intercalarse. Hace falta una actualización apropiada o un protocolo que proteja el conjunto.
14. ¿Qué prueba una ejecución sin avisos de un detector?
Solo que no reportó los problemas que pudo observar y soporta detectar en esa ejecución. No demuestra por sí sola la corrección entre procesos separados.
15. ¿Qué debe pasar si falla el segundo fork?
El padre cierra los canales para liberar a los hijos existentes, recoge los PID creados y descarta el resultado incompleto.
Para practicar y ampliar
- Reproduce a mano los dos órdenes del programa controlado y calcula el contador tras tres rondas.
- Usa el simulador para encontrar dos secuencias distintas que terminen en uno y otra que termine en dos.
- Activa la exclusión del modelo y explica en qué paso queda bloqueado el otro trabajador.
- Ejecuta solapado y serie con 1 y 1000 rondas. Comprueba sus contratos sin depender de la planificación.
- Ejecuta el contador libre varias veces y registra las observaciones sin convertir ninguna cifra en una garantía.
- Compara las casillas con una y cinco millones de iteraciones. Explica por qué el compilador puede simplificar su acumulación local.
- Simula un trabajador fallido y un fallo de fork intermedio; verifica la finalización de los demás.
- Propón una modificación del protocolo controlado que acepte una sola orden de incrementar y la ejecute sin intercalar otra operación.
- Diseña un contador con un único propietario al que los trabajadores envíen contribuciones por mensajes.
- Identifica dónde colocarías la espera y la devolución de un permiso para proteger el contador completo con un semáforo.
Con este tema termina el bloque de memoria compartida. El tema 27 comenzará los semáforos POSIX con nombre: sem_open, sem_wait, sem_post, sem_close y sem_unlink.