1. De transferir mensajes a compartir almacenamiento
En el proyecto del tema 22, un trabajador enviaba un resultado a una cola y el supervisor lo retiraba. El contenido pasaba por una operación de envío y otra de recepción. La unidad de trabajo tenía una longitud, una clase y un identificador que el receptor debía validar.
Con memoria compartida puedes reservar un área para resultados y dejar que cada trabajador escriba directamente en su parte. El supervisor consulta después esas mismas posiciones. No hay una recepción que retire una unidad ni una cola que mantenga automáticamente el orden de los resultados.
Una región compartida permite que varios procesos accedan al mismo almacenamiento. El programa debe definir quién puede modificarlo, cuándo puede consultarse y cómo se reconoce un resultado completo.
| Decisión | Cola de mensajes | Memoria compartida |
|---|---|---|
| Ubicación del resultado. | Una unidad pendiente en la cola. | Una posición elegida dentro de la región. |
| Entrega al consumidor. | La recepción retira el mensaje. | La lectura no borra el dato ni reserva su consumo. |
| Capacidad. | Plazas y tamaño máximo por mensaje. | Bytes y distribución interna del área. |
| Espera de trabajo. | La API puede bloquear al receptor. | Un acceso ordinario a memoria no espera a que un resultado esté preparado. |
| Coordinación. | La cola resuelve aceptación y retirada de unidades. | Debe establecerse un protocolo de acceso a los campos. |
El cambio puede evitar copias explícitas del contenido entre búferes de aplicación y el mecanismo de mensajes. Eso no permite afirmar que cualquier solución compartida será más rápida: influyen el tamaño del trabajo, la contención, la caché, la distribución de datos y el coste de avisar a otros procesos.
En este tema construiremos un intercambio de una sola fase: inicializar, calcular, esperar y leer. Es un primer uso completo que no necesita introducir todavía un semáforo ni un bucle de servicio.
2. Direcciones virtuales y herencia de memoria
Dos procesos tienen espacios de direcciones distintos. La expresión p[0] se interpreta usando el mapeo del proceso que la ejecuta. Que ambos impriman el mismo número con printf("%p", (void *)p) no demuestra que estén accediendo a almacenamiento compartido.
Tras fork, el hijo comienza con una imagen de la memoria del padre. Las variables ordinarias, la pila y las reservas habituales de malloc siguen siendo privadas. Si el hijo modifica una variable local heredada, la copia que consulta el padre no cambia por ese motivo.
Linux utiliza copy-on-write, o copia al escribir, para evitar copiar de inmediato todas las páginas privadas al crear un hijo. Ese ahorro físico no cambia el aislamiento que debe observar el programa. La descripción de creación e implementación está en fork(2).
El puntero que apunta a la región también es una variable privada. Modificar p en el hijo no reasigna el puntero del padre. Lo que puede compartirse es el objeto al que se llega mediante ese puntero, cuando el mapeo se creó para compartirlo.
3. La interfaz de mmap
void *mmap(void *direccion, size_t longitud, int protecciones,
int flags, int fd, off_t desplazamiento);
int munmap(void *direccion, size_t longitud);mmap incorpora un rango de memoria al espacio virtual del proceso. En caso de éxito devuelve su dirección inicial. Al fallar devuelve MAP_FAILED y establece errno: no se comprueba comparando con NULL.
size_t bytes = sizeof(struct resultado);
struct resultado *r = mmap(NULL, bytes,
PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) {
perror("mmap");
/* No acceder a r ni intentar liberar un mapeo inexistente. */
}La llamada anterior no utiliza un archivo de datos: MAP_ANONYMOUS selecciona una región anónima. El descriptor −1 y el desplazamiento cero expresan ese caso. El contrato de mapeo y sus variantes está en mmap(2).
La reserva no tiene el contrato de malloc. Guarda la longitud solicitada junto a la dirección para poder llamar a munmap. No debes pasar esa dirección a free, ni pasar a munmap un puntero arbitrario al interior de una estructura.
4. Elegir dirección, longitud y protecciones
| Argumento | Elección del ejemplo | Motivo |
|---|---|---|
| direccion. | NULL. | Dejar al sistema elegir un rango disponible. |
| longitud. | sizeof de la estructura. | Solicitar espacio para todos sus campos. |
| protecciones. | PROT_READ | PROT_WRITE. | Permitir inicializar, calcular y leer resultados. |
| flags. | Un modo de compartición y MAP_ANONYMOUS. | Definir la relación entre las vistas y el respaldo. |
| fd. | −1. | No hay un descriptor de archivo en el caso anónimo. |
| desplazamiento. | 0. | No se selecciona una porción de archivo. |
Trabaja con el tamaño real del objeto. Aunque el sistema gestione páginas completas, el código del ejemplo solo está autorizado por su diseño a usar los bytes de la estructura. No aproveches el redondeo para escribir posiciones que no forman parte de tu distribución de datos.
Una longitud calculada a partir de una cantidad externa también necesita validación. Antes de obtener cantidad * sizeof *r, comprueba que la cantidad es positiva y no supera SIZE_MAX / sizeof *r. Una multiplicación desbordada podría reservar menos memoria de la necesaria.
No fijes una dirección con MAP_FIXED para «hacer coincidir» los punteros. Aquí la herencia proporciona la relación entre los mapeos. Forzar direcciones añade restricciones innecesarias y puede reemplazar otros rangos del proceso.
Los ejemplos se ejecutan en Linux o en una distribución Linux de WSL, con glibc y GCC. Definen _DEFAULT_SOURCE antes de las cabeceras para exponer MAP_ANONYMOUS al compilar en modo C17 estricto. Esa macro corresponde a glibc; no es una configuración universal de todos los sistemas Unix.
5. MAP_SHARED frente a MAP_PRIVATE
La comparación del tema mantendrá iguales la longitud, las protecciones, el contenido inicial y la secuencia de procesos. Solo cambiaremos el modo del mapeo. Así podremos atribuir el resultado observado a la compartición y no a una demora diferente.
| Propiedad del experimento | MAP_SHARED | MAP_PRIVATE |
|---|---|---|
| Estado inicial heredado. | El hijo ve los datos inicializados. | El hijo también ve los datos inicializados. |
| El hijo escribe un resultado. | Actualiza el almacenamiento compartido. | Actualiza su vista privada mediante copia al escribir. |
| El padre lee después de recoger al hijo. | Obtiene el resultado publicado por el hijo. | Conserva sus valores iniciales. |
| Esperar al hijo. | Delimita el momento de lectura. | No convierte las modificaciones privadas en compartidas. |
| ¿Sirve como canal de resultados de este ejemplo? | Sí, con el protocolo por fases. | No, el resultado queda aislado en el hijo. |
Debes elegir uno de los dos modos; no combinarlos como si fueran capacidades acumulables. Tampoco interpretes PRIVATE como «solo lectura»: el hijo puede escribir porque la protección incluye PROT_WRITE. La diferencia está en a quién afectan esas escrituras.
La copia al escribir se gestiona por páginas, no por cada campo C. Escribir un entero puede provocar una separación de página privada. El simulador posterior representa dos valores independientes para explicar el efecto observable, sin pretender reproducir la asignación física de páginas.
Una copia privada tampoco es una estrategia para tomar una instantánea consistente de un archivo que otros procesos siguen modificando. El experimento utiliza respaldo anónimo e inicialización cerrada antes de fork; no depende de cambios externos en un archivo.
6. Regiones anónimas y momento de creación
- Crear el mapeo. El padre reserva una región anónima compartida.
- Inicializar todos los campos del protocolo. Todavía no existen trabajadores que puedan consultar un estado parcial.
- Ejecutar fork. El hijo hereda el mapeo que ya existía.
- Usar la región conforme al rol. El hijo escribe resultados; el padre espera antes de leerlos.
Si padre e hijo ejecutan cada uno una nueva llamada anónima después de fork, crean dos regiones distintas. Ni usar la misma longitud ni inicializarlas con el mismo contenido las enlaza. El recurso común del ejemplo procede de la llamada realizada antes de separar los procesos.
Si el padre crea una región nueva después de fork, el hijo ya existente no la recibe automáticamente. La creación posterior cambia el espacio virtual del padre. También debes prever que un exec exitoso sustituye la imagen de memoria: el nuevo programa no conserva el puntero heredado como canal utilizable.
Una región anónima no tiene un nombre de aplicación que un programa independiente pueda abrir para conectarse. Resulta adecuada para una familia de procesos creada por el supervisor. En el tema 24 introduciremos shm_open para localizar un objeto compartido desde programas independientes.
En esta familia, los participantes ejecutan el mismo binario y comparten las mismas definiciones de tipos. Por eso usaremos una estructura nativa con enteros y un array interno de caracteres. No es un formato de intercambio portable entre arquitecturas ni un archivo permanente con versión estable.
7. Un protocolo por fases con waitpid
El padre coloca una entrada igual a 7. El hijo calcula su cuadrado, escribe el número y una descripción, retira su mapeo y termina. El padre recoge a ese hijo mediante waitpid y solo entonces consulta el resultado si el estado de terminación indica éxito.
PADRE HIJO
mmap e inicializar
fork -----------------------------> heredar la region
waitpid(hijo, ..., 0) leer la entrada
espera escribir todos los campos de salida
munmap de su vista
_exit(0)
retorna por terminacion <-----------
comprobar el estado
leer y validar el resultado
munmap de su vistaLa espera exitosa por la terminación establece el límite entre la escritura del hijo y la lectura del padre. Si una señal interrumpe waitpid con EINTR, el programa vuelve a esperar al mismo PID. Un intento interrumpido no autoriza a continuar hacia los campos de salida.
Se comprueba primero WIFEXITED y después WEXITSTATUS. Si el hijo muere por una señal, un campo que alcanzó a escribir no convierte el resto en válido. El padre descarta esa salida y comunica el fallo. Las condiciones de espera y recolección se describen en wait(2).
Este esquema sirve cuando el hijo produce una sola vez y termina. Para intercambiar datos repetidamente con un trabajador que sigue vivo necesitaremos avisos, exclusión o semáforos. waitpid no informa de cada resultado intermedio.
8. Programa completo: un hijo calcula un resultado
Guarda el siguiente archivo como region23.c. Acepta exactamente un argumento, shared o private. En ambos modos el hijo calcula lo mismo; el padre compara su vista final con la que corresponde al modo elegido.
La variable local permite comprobar una segunda diferencia: permanece privada incluso cuando la estructura está compartida. Solo el padre imprime los resultados; el hijo usa _exit para no ejecutar la finalización de stdio heredada.
#define _DEFAULT_SOURCE
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
struct resultado {
int entrada;
int cuadrado;
char texto[64];
};
static int esperar(pid_t hijo)
{
int estado;
pid_t r;
do {
r = waitpid(hijo, &estado, 0);
} while (r == -1 && errno == EINTR);
if (r == -1) {
perror("waitpid");
return -1;
}
if (!WIFEXITED(estado)) {
if (WIFSIGNALED(estado))
fprintf(stderr, "Hijo terminado por senal %d\n",
WTERMSIG(estado));
else
fprintf(stderr, "Estado de hijo inesperado\n");
return -1;
}
if (WEXITSTATUS(estado) != 0) {
fprintf(stderr, "Hijo termino con codigo %d\n",
WEXITSTATUS(estado));
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
if (argc != 2 || (strcmp(argv[1], "shared") != 0 &&
strcmp(argv[1], "private") != 0)) {
fprintf(stderr, "Uso: %s shared|private\n", argv[0]);
return EXIT_FAILURE;
}
int compartida = strcmp(argv[1], "shared") == 0;
int modo = compartida ? MAP_SHARED : MAP_PRIVATE;
size_t bytes = sizeof(struct resultado);
struct resultado *r = mmap(NULL, bytes, PROT_READ | PROT_WRITE,
modo | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) {
perror("mmap");
return EXIT_FAILURE;
}
r->entrada = 7;
r->cuadrado = -1;
strcpy(r->texto, "pendiente");
int local = 10;
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
if (munmap(r, bytes) == -1) perror("munmap tras fork");
return EXIT_FAILURE;
}
if (hijo == 0) {
local = 99;
r->cuadrado = r->entrada * r->entrada;
int n = snprintf(r->texto, sizeof r->texto,
"hijo calculo %d", r->cuadrado);
if (n < 0 || (size_t)n >= sizeof r->texto) _exit(2);
if (munmap(r, bytes) == -1) _exit(3);
_exit(0);
}
int salida = EXIT_FAILURE;
if (esperar(hijo) == 0) {
/* Solo se consultan los resultados tras recoger al hijo. */
printf("Modo: %s\n", argv[1]);
printf("Entrada: %d\n", r->entrada);
printf("Cuadrado visto por el padre: %d\n", r->cuadrado);
printf("Texto visto por el padre: %s\n", r->texto);
printf("Variable local del padre: %d\n", local);
int esperado = compartida ? 49 : -1;
const char *texto = compartida ? "hijo calculo 49" : "pendiente";
if (r->entrada == 7 && r->cuadrado == esperado &&
strcmp(r->texto, texto) == 0 && local == 10)
salida = EXIT_SUCCESS;
else
fprintf(stderr, "La vista del padre no coincide\n");
}
if (munmap(r, bytes) == -1) {
perror("munmap padre");
salida = EXIT_FAILURE;
}
return salida;
}La cadena «pendiente» cabe en el array de 64 caracteres y snprintf comprueba que la descripción final también cabe. El ejemplo tiene una entrada fija pequeña para que el cuadrado sea representable como int. Si admites entradas externas, valida su rango antes de multiplicar.
El hijo no publica punteros a su pila ni devuelve la dirección de un búfer local. El array de caracteres forma parte de la propia región. El padre puede consultarlo después de que desaparezca el proceso que escribió el texto.
9. Compilar y comparar ambos modos
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic region23.c -o region23
$ ./region23 shared
Modo: shared
Entrada: 7
Cuadrado visto por el padre: 49
Texto visto por el padre: hijo calculo 49
Variable local del padre: 10
$ echo $?
0
$ ./region23 private
Modo: private
Entrada: 7
Cuadrado visto por el padre: -1
Texto visto por el padre: pendiente
Variable local del padre: 10
$ echo $?
0El retorno cero de private es intencional: la prueba confirmó el aislamiento esperado. No significa que el padre recibiera el cuadrado. La aplicación valida dos contratos distintos según el argumento.
La optimización -O2 no debe modificar estas salidas. El protocolo no depende de esperar una cantidad aproximada de tiempo ni de observar reiteradamente un campo con un bucle vacío. La espera al hijo debe funcionar aunque el planificador lo ejecute antes de que el padre llegue a waitpid.
Si necesitas lanzar el comando desde PowerShell, entra primero a tu distribución con wsl -d Ubuntu y compila dentro de ella. Estos ejemplos utilizan la interfaz de procesos y memoria de Linux; un compilador de C dirigido a Windows no proporciona automáticamente fork y mmap.
10. Leer el programa y sus rutas de error
Inicialización antes de que exista el lector
La entrada, el valor centinela y el texto se asignan antes de fork. Nadie puede observar media inicialización del padre. El centinela −1 ayuda a comparar vistas; no se consulta continuamente como una señal de «listo».
Un único escritor y una lectura posterior
El hijo lee la entrada y modifica los campos de salida. Mientras tanto, el padre no toca esos campos. Después de recoger al hijo ya no habrá nuevas escrituras suyas. La validación compara contenido estable.
Retirar la vista del hijo no borra la del padre
El hijo ejecuta munmap antes de terminar. El padre conserva su propio mapeo y, en shared, el dato publicado. Retirar un rango de un proceso no equivale a sobrescribir los bytes de los demás.
No consumir una salida parcial ante fallo
El hijo puede terminar con código 2 si falla el formato o 3 si falla munmap. El padre considera fallida la operación en ambos casos. Aunque algunos bytes contengan el resultado esperado, no trata una ejecución incompleta como una tarea aceptada.
| Punto de fallo | Recursos existentes | Acción del programa |
|---|---|---|
| Argumento inválido. | Ningún mapeo ni hijo. | Imprime el uso y retorna error. |
| mmap. | No se obtuvo la región. | Informa errno y no accede al puntero. |
| fork. | Solo el mapeo del padre. | Retira esa región y retorna error. |
| Trabajo o terminación del hijo. | El padre conserva la región. | Recoge al hijo, descarta la salida y retira su vista. |
| munmap del padre. | El hijo ya fue recogido. | Informa el fallo y retorna error. |
El programa es independiente y no instala una política que descarte SIGCHLD o recoja hijos desde otro hilo. Esa condición permite que su llamada a waitpid sea la responsable de su hijo directo. Integrarlo en otro supervisor requiere respetar quién conserva y recoge cada PID.
11. Programa completo: resultados en casillas independientes
El siguiente paso consiste en reservar tres casillas. Cada hijo recibe un índice, calcula una suma y escribe exclusivamente su casilla. El padre espera a todos antes de leer el array. No existe un contador compartido que varios hijos deban incrementar.
El hijo 0 suma de 1 a 100, el 1 de 101 a 200 y el 2 de 201 a 300. La suma total debe ser 45150. Los rangos son constantes y pequeños; el ejemplo no recibe límites que puedan producir un desbordamiento.
#define _DEFAULT_SOURCE
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define HIJOS 3
struct casilla {
long suma;
int completa;
};
int main(void)
{
size_t bytes = HIJOS * sizeof(struct casilla);
struct casilla *r = mmap(NULL, bytes, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (r == MAP_FAILED) {
perror("mmap");
return EXIT_FAILURE;
}
for (int i = 0; i < HIJOS; ++i) {
r[i].suma = 0;
r[i].completa = 0;
}
pid_t pids[HIJOS];
int creados = 0;
int fallo = 0;
for (int i = 0; i < HIJOS; ++i) {
pid_t pid = fork();
if (pid == -1) {
perror("fork");
fallo = 1;
break;
}
if (pid == 0) {
long suma = 0;
int inicio = i * 100 + 1;
int fin = (i + 1) * 100;
for (int n = inicio; n <= fin; ++n) suma += n;
r[i].suma = suma;
r[i].completa = 1;
if (munmap(r, bytes) == -1) _exit(2);
_exit(0);
}
pids[creados++] = pid;
}
/* Recoger incluso a los ya creados si un fork posterior fallo. */
for (int i = 0; i < creados; ++i) {
int estado;
pid_t pid;
do {
pid = waitpid(pids[i], &estado, 0);
} while (pid == -1 && errno == EINTR);
if (pid == -1) {
perror("waitpid");
fallo = 1;
} else if (!WIFEXITED(estado) || WEXITSTATUS(estado) != 0) {
fprintf(stderr, "Fallo del hijo %d\n", i);
fallo = 1;
}
}
if (!fallo && creados == HIJOS) {
long total = 0;
for (int i = 0; i < HIJOS; ++i) {
long esperado = 5050L + i * 10000L;
if (r[i].completa != 1 || r[i].suma != esperado) {
fprintf(stderr, "Casilla %d invalida\n", i);
fallo = 1;
break;
}
printf("Casilla %d: %ld\n", i, r[i].suma);
total += r[i].suma;
}
if (!fallo) {
printf("Total: %ld\n", total);
if (total != 45150L) fallo = 1;
}
}
if (munmap(r, bytes) == -1) {
perror("munmap padre");
fallo = 1;
}
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic casillas23.c -o casillas23
$ ./casillas23
Casilla 0: 5050
Casilla 1: 15050
Casilla 2: 25050
Total: 45150La salida es estable porque imprime el padre después de las esperas, recorriendo índices. Un hijo puede haber terminado mucho antes que otro. Esperar primero por pids[0] no obliga a que ese hijo sea el primero en terminar.
El campo completa se consulta después de recoger a todos los hijos. Es una comprobación del resultado, no una primitiva de sincronización. Ponerlo al final de la función del hijo no autoriza al padre a leerlo en paralelo sin otro protocolo.
Si falla un fork intermedio, se deja de crear hijos, se recogen los existentes y se descarta el conjunto de resultados. Esos hijos realizan un cálculo finito e independiente; no necesitan que lleguen a existir los demás para terminar.
Aunque distintas casillas puedan ocupar una misma página o línea de caché, siguen siendo objetos distintos para este diseño. Compartir una línea puede afectar al rendimiento por tráfico de coherencia, sin convertir las escrituras a campos separados en la actualización concurrente de un mismo contador.
12. Mapeos respaldados por un archivo
La palabra «compartida» describe la relación entre accesos; «anónima» describe el tipo de respaldo. Son decisiones distintas. También se puede mapear un archivo existente y usarlo como almacenamiento común, con un descriptor válido y un desplazamiento apropiado.
/* El archivo contiene al menos bytes bytes desde el comienzo. */
void *base = mmap(NULL, bytes, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
if (base == MAP_FAILED) {
perror("mmap archivo");
/* Limpiar los recursos previos y no acceder a base. */
} else {
/* El mapeo mantiene su referencia al respaldo. */
/* Cerrar fd, comprobando el retorno, no retira base. */
/* Usar base segun el protocolo acordado y luego munmap. */
}Este fragmento es una comparación de interfaz, no un programa para crear archivos. Hay que garantizar su tamaño antes de acceder a la zona prevista. Reducir el archivo mientras otro proceso sigue usando el rango puede invalidar accesos y provocar SIGBUS.
El desplazamiento de un mapeo de archivo se alinea al tamaño de página. Si más adelante necesitas mapear desde una posición arbitraria, tendrás que alinear el comienzo y ajustar la posición dentro del rango. Los ejemplos de este tema usan desplazamiento cero y no necesitan ese cálculo.
Un archivo compartido introduce además la pregunta de cuándo sus cambios llegan al almacenamiento. Visibilidad entre procesos y persistencia son requisitos distintos. msync con MS_SYNC solicita la actualización del archivo respaldante y espera su finalización, según msync(2).
No llames a msync como sustituto de avisar al lector o proteger una estructura. Tampoco lo necesita nuestro resultado anónimo para aparecer en el padre tras la espera. No hay un archivo de datos al que debamos volcar ese resultado.
En el tema siguiente, shm_open nos dará un descriptor de un objeto de memoria compartida con nombre. A continuación habrá que dimensionarlo, mapearlo y coordinar su inicialización. El nombre resolverá cómo encontrar el recurso; no resolverá por sí mismo quién puede usar sus campos.
13. Compartir no resuelve las carreras
El dato puede estar en una región compartida y aun así ser usado incorrectamente. Debes distinguir tres preguntas: dónde están los bytes, quién tiene permiso para acceder y qué orden deben respetar esos accesos. MAP_SHARED solo participa en la primera.
/* No usar como contador entre procesos sin proteccion. */
region->contador++;
/* La operacion requiere conceptualmente:
leer el valor, calcular uno mas y escribir el nuevo valor.
Dos procesos pueden partir del mismo valor anterior. */Si ambos parten de 10, ambos podrían intentar dejar 11. No basta con que un entero quepa en una palabra de la máquina: el incremento combina lectura, cálculo y escritura. El tema 26 estudiará estos errores y los límites de los experimentos que intentan observarlos.
Otra tentación consiste en esperar con while (!r->lista) { }. Esa espera activa no contiene una operación de sincronización entre procesos. Además de consumir CPU, presupone reglas de visibilidad y orden que el programa no estableció.
Declarar volatile un campo no crea exclusión mutua, no vuelve atómico un incremento y no establece un protocolo que publique los demás campos. No es la solución para convertir una bandera ordinaria en un aviso entre procesos.
Un sleep tampoco prueba que el trabajador terminó. Una pausa puede vencer antes del cálculo en una máquina cargada o durar mucho más de lo necesario en otra. En nuestros programas, waitpid expresa directamente la condición relevante: el hijo terminó y su estado se comprobó.
Para un productor y un consumidor que siguen vivos, los temas de semáforos introducirán operaciones que permitan esperar datos y proteger accesos. Un mutex entre procesos también requiere la configuración y ubicación apropiadas; no basta con colocar en la región un mutex inicializado para uso privado.
Los dos programas evitan esas carreras por construcción: el padre inicializa antes de fork, los hijos tienen salidas de su propiedad y el padre lee después de las esperas. El diseño de responsabilidades reduce el trabajo de sincronización necesario.
14. Vida útil y retirada de los mapeos
Un mapeo pertenece al espacio virtual de un proceso. Cada participante retira su propia vista mediante munmap. La terminación del proceso también provoca la retirada de sus mapeos, pero el ejemplo realiza la operación explícitamente para enseñar la responsabilidad y comprobar el resultado.
| Operación | Efecto en este diseño | Lo que debe recordar el programa |
|---|---|---|
| munmap en el hijo. | Retira su rango virtual. | El hijo no puede seguir accediendo a r. |
| munmap en el padre. | Retira el rango del padre. | Otros procesos pueden conservar sus propias vistas. |
| waitpid. | Recoge el estado y los recursos de un hijo terminado. | No retira el mapeo que conserva el padre. |
| close de un descriptor de respaldo. | Cierra esa referencia de descriptor. | No sustituye munmap. |
| Fin de la última referencia a la región anónima. | El almacenamiento deja de ser necesario para la familia. | No queda un nombre de aplicación que retirar con unlink. |
Conserva la dirección base y la longitud de la reserva. Una subestructura puede tener su propio puntero de trabajo, pero la limpieza de la región completa debe usar el rango original. Después de munmap, los punteros derivados también dejan de ser válidos.
En este tema no hay shm_unlink ni archivo temporal que borrar. Añadir esas operaciones a una región anónima sería confundir dos modelos de recurso. Al pasar al objeto POSIX con nombre, distinguiremos por separado descriptor, mapeo y nombre.
La liberación de memoria tampoco equivale a recoger procesos. Si omites waitpid y el hijo termina mientras su padre sigue vivo, puedes dejar un zombi. Si omites munmap en una aplicación larga, puedes conservar rangos que ya no necesitas.
15. Diagnóstico con strace y /proc
La salida de un programa comprueba los datos. Las herramientas permiten relacionarlos con las operaciones del sistema. Ejecuta primero el ejemplo sin traza y después inspecciona ambos modos, conservando la misma entrada.
$ strace -f -e trace=mmap,munmap,clone,fork,vfork,wait4,exit_group ./region23 shared
$ strace -f -e trace=mmap,munmap,clone,fork,vfork,wait4,exit_group ./region23 privateBusca la llamada del ejemplo con MAP_ANONYMOUS y el modo elegido. Verás también mapeos del cargador y las bibliotecas; no todos pertenecen a tu estructura. En Linux, las funciones de biblioteca fork y waitpid pueden aparecer como clone y wait4 en la traza.
Una escritura como r->cuadrado = 49 no aparece como un write al canal de IPC. Es una instrucción de acceso a memoria. La traza de llamadas al sistema permite estudiar la creación y retirada, pero no reconstruye cada carga y almacenamiento del programa.
Observar un proceso antes de que termine
El ejemplo es breve. Para un laboratorio, crea una copia que, después de inicializar y antes de fork, imprima su PID y la dirección base, vacíe stdout con fflush y espere una entrada de terminal mediante getchar. Esa pausa solo facilita la inspección: no forma parte de la coordinación entre padre e hijo.
printf("PID %ld; base %p; bytes %zu\n",
(long)getpid(), (void *)r, bytes);
fflush(stdout);
(void)getchar();$ cat /proc/12345/mapsLocaliza el rango que contiene la dirección impresa. En permisos, la letra s identifica compartición y p una región privada; r y w indican lectura y escritura. El formato se documenta en proc_pid_maps(5).
El nombre mostrado para el respaldo anónimo puede variar según el sistema. No bases una prueba en encontrar una ruta concreta. El rango virtual y sus permisos son las pistas útiles para este ejercicio.
16. Explorar la herencia y la copia al escribir
Avanza la misma secuencia en los dos modos. El valor de salida comienza en −1 y el hijo intenta dejar 49. El modelo distingue la existencia de una vista, su contenido conceptual y el momento en que el protocolo autoriza al padre a consultar el resultado.
FaseRegión inicializada antes de fork
Contenido de la vista del padre−1; aún no se consulta como resultado
Vista del hijoEl hijo todavía no existe
Relación entre vistasUna sola vista inicial
Crea el hijo para observar qué hereda.
El modelo muestra valores internos con fines didácticos. El programa C no inspecciona el resultado durante la escritura ni utiliza los estados del simulador como una bandera compartida. La lectura real del padre ocurre en el paso posterior a waitpid.
En modo privado representamos la separación cuando el hijo escribe. La copia física exacta de páginas, sus fallos y las optimizaciones del núcleo quedan fuera de esta simulación. El efecto importante es que esperar no fusiona las dos vistas.
17. Pruebas y errores frecuentes
Una comparación reproducible
$ for modo in shared private; do
for n in $(seq 1 20); do
./region23 "$modo" > /dev/null || exit 1
done
done
$ ./casillas23
$ ./region23 otro
Uso: ./region23 shared|private
$ echo $?
1La repetición debe mantener el contrato de cada modo. No modifica la demostración de corrección: muchos resultados acertados no convertirían una versión con accesos concurrentes sin coordinación en una implementación válida.
Variantes controladas
- Fallo del trabajador. En una copia del primer programa, inserta _exit(7) al comienzo de la rama hija. El padre debe informar el código, devolver error y no imprimir campos de resultado como si fueran válidos.
- Fallo de creación intermedio. En una copia de casillas23.c, simula que el tercer intento de fork falla. El padre debe recoger los dos hijos existentes y descartar el conjunto incompleto.
- Casillas privadas. Cambia solo MAP_SHARED por MAP_PRIVATE en el segundo programa. La validación del padre debe fallar: sus casillas seguirán con completa igual a cero.
- Dato local adicional. Añade otra variable local inicializada antes de fork y modifícala en el hijo. El padre debe conservar su valor inicial en ambos modos.
- Región independiente. Diseña una variante que cree dos mapeos anónimos después de fork. Explica por qué no forman un canal aunque ambos usen MAP_SHARED.
| Síntoma | Revisión | Corrección |
|---|---|---|
| El padre conserva −1. | ¿Se eligió private o se creó otra región? | Usar el mapeo shared heredado y conservar la espera. |
| mmap retorna MAP_FAILED. | Revisar errno, tamaño, flags y respaldo. | No desreferenciar el retorno; corregir la causa concreta. |
| Un acceso provoca SIGSEGV. | Rango, protecciones y vida útil del puntero. | No escribir en solo lectura ni usar una vista retirada. |
| Un mapeo de archivo provoca SIGBUS. | Tamaño del respaldo y posibles truncamientos. | Dimensionar y mantener válido el rango usado. |
| Una cadena contiene basura. | Capacidad y terminación NUL del array. | Validar longitud y publicar una cadena completa. |
| El hijo murió y hay datos parciales. | Estado de waitpid. | Descartar la salida de un trabajador fallido. |
| Un contador pierde incrementos. | Hay varios escritores sobre el mismo objeto. | Asignar casillas o introducir sincronización apropiada. |
| El padre espera indefinidamente. | El hijo no terminó o sigue detenido. | Revisar el cálculo y diseñar un plazo si el trabajo puede no terminar. |
Los cálculos de los ejemplos son finitos y no incorporan un presupuesto global de supervisión como el proyecto del tema 22. Si el trabajo real pudiera quedar bloqueado, habría que añadir detección, cancelación y recolección coherentes. Compartir el resultado no proporciona recuperación automática ante un trabajador detenido.
18. Resumen
- La memoria compartida necesita una distribución de datos y un protocolo de acceso.
- Las variables ordinarias siguen siendo privadas después de fork.
- mmap devuelve la base de la región o MAP_FAILED; la longitud debe ser válida.
- MAP_SHARED permite compartir cambios; MAP_PRIVATE mantiene las escrituras privadas.
- Una región anónima creada antes de fork puede heredarse como recurso común.
- Crear dos regiones anónimas por separado no las conecta.
- La secuencia inicializar, crear hijos, calcular, esperar y leer evita accesos concurrentes a la salida.
- El estado de terminación se comprueba antes de confiar en el resultado.
- Asignar una casilla por hijo evita que todos actualicen un mismo objeto.
- volatile, sleep y msync no sustituyen un protocolo de sincronización.
- Cada proceso retira su propia vista; el padre además recoge a sus hijos.
19. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones. Relaciona cada respuesta con una línea de los programas o un paso del explorador.
1. ¿Por qué no basta con reservar memoria mediante malloc antes de fork?
Porque esa memoria ordinaria sigue siendo privada en cada proceso. El hijo hereda el contenido inicial, pero sus escrituras no se convierten en resultados del padre.
2. ¿Qué demuestra que dos procesos impriman la misma dirección?
Solo que usan el mismo valor virtual en ese punto. Para compartir almacenamiento importa cómo se creó o conectó el mapeo, no la coincidencia numérica del puntero.
3. ¿Por qué se comprueba MAP_FAILED en lugar de NULL?
Porque es el valor de error que especifica mmap. La comprobación debe seguir el contrato de la operación que se llamó.
4. ¿El modo private impide que el hijo escriba?
No. PROT_WRITE le permite escribir. MAP_PRIVATE hace que esas escrituras permanezcan en su vista privada, sin publicar el resultado al padre.
5. ¿Por qué el mapeo se crea antes de fork?
Para que el hijo herede una vista de la región ya existente. Dos llamadas anónimas independientes después de fork crearían recursos distintos.
6. ¿waitpid copia el resultado desde la memoria privada del hijo?
No. Espera y recoge su terminación. Si el dato era privado, seguirá sin estar disponible en la vista del padre.
7. ¿Por qué no se consulta el cuadrado mientras trabaja el hijo?
Porque este protocolo no establece un intercambio concurrente. El padre espera la terminación y valida el estado antes de leer los campos.
8. ¿Qué hace el padre si waitpid falla con EINTR?
Vuelve a esperar al mismo PID. Una interrupción no demuestra que el hijo haya terminado ni permite consumir su salida.
9. ¿Por qué el hijo usa _exit?
Para terminar sin ejecutar el vaciado y la finalización de stdio heredados del padre. El padre es quien imprime y retorna normalmente de main.
10. ¿munmap en el hijo destruye el resultado del padre?
No. Retira la vista del hijo. El padre conserva su mapeo y el almacenamiento compartido sigue disponible para él.
11. ¿El campo completa del segundo ejemplo es un semáforo?
No. Es un dato validado después de esperar a los hijos. Leerlo continuamente mientras otro proceso escribe requeriría otro mecanismo de coordinación.
12. ¿Por qué tres hijos pueden escribir sin un contador protegido?
Cada uno escribe objetos distintos, dentro de su casilla. El padre no consulta las salidas hasta que terminan todos.
13. ¿Se necesita msync para que el padre vea el resultado anónimo?
No. msync trata la actualización de un archivo respaldante. La compartición y la espera del ejemplo no dependen de un volcado a archivo.
14. ¿Se puede guardar un puntero a la pila del hijo como resultado?
No sería un resultado válido para el padre. El destino seguiría fuera de la región compartida y su vida útil no continuaría después del hijo. Se deben colocar los datos dentro del área adecuada.
15. ¿Cómo se conectaría un programa independiente a esta región anónima?
No dispone de un nombre que pueda abrir para localizarla. El tema siguiente presentará un objeto POSIX con nombre para construir esa conexión.
Para practicar y ampliar
- Ejecuta region23 en ambos modos y explica por separado el entero, la cadena y la variable local.
- Cambia la entrada fija por 9 y ajusta las expectativas. Verifica el contrato de shared y el de private.
- Añade un segundo resultado a la estructura y haz que el hijo complete ambos antes de terminar.
- Amplía el programa de casillas a cuatro hijos con rangos de cien números. Calcula primero los valores esperados.
- Simula un hijo fallido y un fork intermedio fallido. Comprueba el retorno y la recolección de todos los hijos creados.
- Instrumenta una copia para inspeccionar /proc y relaciona la dirección de r con sus permisos.
- Explica por qué una misma página puede contener casillas distintas sin que los hijos incrementen un mismo contador.
- Dibuja la vida útil de la región desde mmap hasta el último munmap, incluyendo las vistas heredadas.
- Diseña, sin implementarlo todavía, un intercambio de dos resultados sucesivos con un hijo que permanezca vivo. Identifica qué avisos y permisos de escritura faltan.
- Describe qué cambiaría para conectar dos ejecutables independientes: localizar el recurso, reservar tamaño, inicializarlo y acordar la distribución de datos.
El tema 24 presentará memoria compartida POSIX con shm_open: crear un objeto con nombre, darle tamaño con ftruncate, mapearlo y distinguir close, munmap y shm_unlink.