← Comunicación entre ProcesosBloque 11 · Aplicaciones en sistemas reales · Tema 46 de 52

Tema 46

IPC en bases de datos

Compartir páginas permite cooperar sin copiar cada dato entre procesos, pero no decide quién puede modificar una página, cuándo otro lector puede verla ni qué sobrevivirá a un fallo. Vas a relacionar búferes, colas y sincronización con un diario de recuperación, y a comprobar por qué publicar un resultado en memoria no equivale a confirmarlo de forma durable.

1. Procesos que cooperan dentro de una base de datos

Una consulta puede involucrar un proceso que atiende al cliente, otro que realiza trabajo paralelo y participantes que escriben datos o mantienen estructuras internas. La arquitectura concreta cambia según el motor: algunos usan procesos, otros hilos y otros una combinación. Lo común es que el trabajo necesita un estado y unas reglas de coordinación.

IPC dentro de una base de datos conecta trabajo, estado compartido y notificaciones. Su corrección depende tanto de quién posee cada recurso como del orden en que se publican cambios y se confirma su persistencia.

Esquema conceptual · participantes y recursos
clientes ──► procesos de consulta ──► cola acotada ──► trabajadores
                         │                                │
                         └──── búferes compartidos ───────┘
                                      │
                               registros de cambio
                                      ▼
                              diario de recuperación
                                      │
                             páginas persistentes

Un mismo mecanismo no resuelve todos los problemas. La memoria compartida evita transportar cada página por un socket, un semáforo puede anunciar trabajo disponible y un diario permite reconstruir cambios después de perder el estado volátil. Ninguna de esas piezas, por separado, constituye una transacción.

Este tema no implementa SQL, índices ni un gestor completo de transacciones. Utiliza una actualización de un único valor para observar el orden entre compartir, sincronizar y recuperar. Las simplificaciones se mantienen explícitas para que el resultado del experimento no se confunda con las garantías de un motor real.

2. Qué aporta la memoria compartida

Varios participantes pueden mapear una región que contiene páginas y metadatos. Cada proceso tiene su espacio de direcciones, por lo que una dirección virtual almacenada por uno no es un identificador portable para otro. Se usan índices, identificadores de página o desplazamientos relativos a la región validada.

ElementoRepresentación compartibleRegla necesaria
Página.Identificador lógico y bytes de tamaño conocido.Validar longitud y estado antes de usarla.
Referencia a un búfer.Índice y generación de la ranura.Detectar reutilización; no confiar solo en el índice.
Enlace de una lista.Desplazamiento dentro del segmento.Comprobar alineación y que el rango quede dentro del mapeo.
Estado de trabajo.Identidad, fase y dueño.Publicar cambios con un protocolo sincronizado.

MAP_SHARED establece cómo se comparten las modificaciones del mapeo; no convierte una secuencia de escrituras ordinarias en una operación atómica. Tampoco reemplaza exclusión, orden de publicación o validación de versiones.

La región anónima compartida del laboratorio se hereda mediante fork. Su contenido sirve para cooperar durante esa ejecución. No es un archivo de base de datos, no tiene un nombre que otro programa pueda reabrir después y no conserva por sí mismo un estado recuperable tras perder todos los procesos.

volatile tampoco es un protocolo entre procesos. Para el intercambio del ejemplo se utilizan semáforos POSIX colocados en la región compartida e inicializados con pshared distinto de cero, según sem_init(3).

3. Búferes de páginas, referencias y reemplazo

Un buffer pool conserva en memoria copias de páginas persistentes. Una ranura puede estar libre, cargándose, válida, modificada o en escritura. Saber que hay bytes en ella no basta: otro proceso podría estar completando una lectura o reutilizándola para otra página.

Metadato conceptualPara qué sirveQué no garantiza
Identidad de página y generación.Relacionar una ranura con el contenido esperado.Que el contenido no cambie durante su uso.
Pin o referencia de uso.Impedir reemplazo mientras un participante necesita la ranura.Exclusión para modificar sus bytes.
Protección del contenido.Coordinar lectores y escritores del búfer.Aislamiento de una transacción completa.
Marca dirty.Indicar diferencias pendientes respecto del respaldo.Que el cambio ya sea durable o deba ser visible a todos.
Posición asociada del diario.Relacionar la versión de página con registros necesarios para recuperarla.Que esos registros ya se hayan sincronizado.

Un reemplazador busca una ranura que pueda desalojar. Si está fijada mediante un pin, no debe reciclarla; si está modificada, puede requerir escritura bajo las reglas del diario. De lo contrario, una consulta puede observar bytes de otra página bajo una referencia que parecía válida.

El pin se libera también en los caminos de error y cancelación. Perder referencias de uso reduce capacidad disponible aunque no exista una fuga de malloc. Un contador mal decrementado puede permitir reemplazo prematuro; uno que nunca baja puede impedir el reemplazo para siempre.

El laboratorio usa una sola ranura y una sola actualización; no implementa este reemplazador. La ranura permite estudiar el traspaso de propiedad sin introducir una política de caché que oculte el orden del experimento.

4. Separar protección de memoria y aislamiento

Proteger una estructura de memoria evita que dos participantes rompan sus invariantes al modificarla simultáneamente. El aislamiento decide qué versiones o conflictos pueden observar transacciones distintas. Mantener un mutex durante una asignación no define por sí solo una política de aislamiento.

Es útil distinguir las protecciones breves de estructuras internas de los bloqueos lógicos que representan conflictos de transacciones. La terminología concreta cambia según el motor. Aquí importa el alcance: una operación de lista, una página, una fila lógica y una transacción no tienen necesariamente la misma vida.

Un motor puede usar versiones para permitir lecturas mientras hay escrituras, o bloqueos para coordinar accesos incompatibles. En ambos casos se requieren reglas de visibilidad y finalización. Que una página física contenga un cambio todavía no significa que cualquier consulta deba devolverlo.

Evitar esperas dentro de una protección breve

Hacer una escritura lenta o esperar capacidad de una cola mientras se mantiene una protección global puede detener a todo el grupo. Primero define qué debe permanecer protegido; luego organiza reservas y publicación sin exponer estados incompletos.

Si un proceso cae con un mutex convencional adquirido, otros pueden quedar esperando. Un mutex robusto permite detectar ciertos casos de muerte del dueño, pero todavía hay que reparar la estructura y decidir qué cambios son válidos. No recupera automáticamente una transacción ni sustituye el diario.

5. Colas de trabajo y transferencia de propiedad

Una cola conecta productores de solicitudes con consumidores que las ejecutan. El registro debe identificar trabajo, recursos, límites y destino de respuesta. Un puntero a memoria privada del productor no se vuelve válido en el consumidor por introducirlo en una cola compartida.

Estados conceptuales de una ranura
LIBRE → RESERVADA → PUBLICADA → TOMADA → TERMINADA → LIBRE
            │            │          │
            └── error ───┴──────────┴──► política de recuperación

campos posibles: id, generacion, operacion, offset, longitud, estado, dueño

Un contador de huecos y otro de elementos no bastan si varios procesos pueden modificar índices y metadatos a la vez. Hay que proteger esas transiciones y conservar la correspondencia entre permisos y ranuras. Una caída entre reservar y publicar puede perder capacidad si no existe una política de recuperación.

En el laboratorio hay un productor, un consumidor y una sola solicitud. El padre escribe solicitud y publica tarea; el hijo consume tarea, escribe visible y publica recibido. Un tercer semáforo permite al padre autorizar la continuación después de inspeccionar el archivo. No hay reutilización concurrente de ranuras ni varios productores compitiendo.

Ese diseño es una cola de capacidad uno especializada, no una implementación general de una cola recuperable. Si el hijo muere antes de publicar recibido, el padre abandona el intercambio al vencer su plazo, recoge al hijo y destruye la región; no inventa un sem_post para fingir que la operación terminó.

En un sistema de consultas real, la cola se dimensiona según memoria, costo y capacidad de consumidores. Cuando se llena, se aplica contrapresión o rechazo. Una cola ilimitada transforma una sobrecarga de consultas en una pérdida de memoria y una latencia creciente.

6. Visibilidad, aceptación y durabilidad

AfirmaciónEvidencia posibleLímite
La solicitud fue aceptada.Entró en una cola bajo un protocolo válido.No demuestra que se ejecutó.
El valor es visible.Un lector obtiene una versión publicada mediante sincronización.No demuestra que sobrevivirá al fallo considerado.
Los bytes llegaron al núcleo.write o pwrite completó.Pueden seguir solo en cachés volátiles.
Se confirmó sincronización.fsync tuvo éxito para el archivo requerido.Necesita un protocolo correcto y un almacenamiento que respete su contrato.
El cliente recibió éxito.Respuesta válida llegó a ese cliente.No implica durabilidad salvo que el contrato de éxito la exija.

La palabra «confirmado» necesita una definición. Una base puede ofrecer un modo de confirmación durable y otro que acepte riesgo de pérdida reciente a cambio de menor espera. Esa elección debe pertenecer al contrato y no surgir accidentalmente del orden de dos instrucciones.

Hay dos ejes diferentes: qué versión puede ver otro participante y qué información permitirá recuperarla tras un fallo. El programa simplifica el primero a una publicación sincronizada de un número; no reproduce las reglas de visibilidad de una transacción SQL.

También se define el fallo: terminar un proceso, reiniciar el núcleo, perder energía o perder el dispositivo no son equivalentes. Un diario en tmpfs puede ser legible después de matar al hijo y desaparecer al reiniciar la máquina. Una repetición de lecturas no certifica resistencia a cortes de energía.

7. Ordenar el diario antes de confirmar

Un diario de recuperación registra información suficiente para reconstruir cambios. En un esquema de redo, la recuperación vuelve a aplicar registros válidos a una base conocida. Para que funcione, el orden debe relacionar registros, páginas y confirmaciones.

Orden simplificado de una confirmación durable
preparar cambio
    ↓
escribir registro completo en diario
    ↓
sincronizar diario y comprobar resultado
    ↓
publicar confirmación según el contrato
    ↓
escribir páginas y realizar checkpoints bajo reglas de recuperación

El principio write-ahead exige que la información necesaria del diario alcance almacenamiento antes que las páginas cuya recuperación depende de ella. Una confirmación durable también debe esperar la sincronización requerida. La explicación de WAL en PostgreSQL relaciona ese orden con la posibilidad de rehacer páginas sin sincronizar cada página en cada commit.

El ejemplo guarda directamente dos estados completos en un diario pequeño, sin archivo de páginas separado. Cada registro completo y válido representa un estado recuperable del modelo. No admite varias transacciones, rollback ni registros de preparación separados de registros de commit.

fsync sincroniza un archivo y puede informar errores diferidos. La publicación de un archivo nuevo también exige considerar su directorio; se documenta en fsync(2). El ejemplo sincroniza la base inicial, el directorio nuevo y su directorio contenedor antes de empezar la actualización.

msync se aplica a cambios de un archivo mapeado, según msync(2). No convierte una región anónima con semáforos en un diario durable y no aporta por sí solo framing de registros, atomicidad de transacciones ni recuperación.

8. Contrato del laboratorio y formato del registro

El programa db46.c crea un directorio privado nuevo en el directorio de trabajo y un archivo diario.bin con un estado base de valor cero. Después crea una región anónima compartida y un hijo que recibe la solicitud de publicar el valor 7. Los semáforos fuerzan los puntos de observación sin usar pausas para adivinar el orden.

ModoAntes de publicar visible=7Después de publicar
seguro.El hijo escribe el registro de valor 7 y completa fsync.El padre puede observar 7 y recuperar 7 del diario.
anticipado.El hijo solo cambia la memoria compartida.El padre observa 7 mientras el diario todavía contiene cero.
Escenario normal.Después de la observación, el padre autoriza continuar. En anticipado, el hijo escribe y sincroniza entonces el registro; ambos modos terminan recuperando 7.
Escenario corte.El hijo termina con código 50 inmediatamente después de publicar, sin ejecutar el resto. En anticipado se recupera cero; en seguro se recupera 7.

«Corte» significa una salida de proceso inyectada con _exit; no simula un apagón del equipo. En anticipado se omite determinísticamente la escritura, por lo que la diferencia observada no depende de que el núcleo decida vaciar o conservar una caché.

BytesCampo del registro de 32 bytes
0–7.Cabecera fija DB46, versión 1 y tres bytes cero.
8–15.Secuencia uint64 en little endian: 0 para base y 1 para actualización.
16–23.Valor uint64 en little endian.
24–31.Checksum FNV-1a de 64 bits sobre los primeros 24 bytes.

El formato no escribe una struct de C directamente: evita depender de padding, alineación o endianess del equipo. El checksum detecta muchas alteraciones accidentales, pero no es una protección criptográfica ni garantiza detectar toda corrupción posible.

La recuperación exige el registro base completo, admite como máximo un registro adicional y rechaza una cabecera, secuencia o checksum inválidos en un registro completo. Una cola final incompleta se informa y no se aplica. No se buscan registros posteriores saltando por encima de una corrupción.

9. Laboratorio completo en C

Guarda el código como db46.c. El padre administra los recursos y un plazo global de siete segundos. El hijo es el único escritor del diario de actualización. Las observaciones del padre ocurren antes de autorizar esa escritura en anticipado o después de terminar el hijo; no hay lectura concurrente de un registro que se está modificando.

db46.c · cola de una ranura, publicación y recuperación
#define _GNU_SOURCE
#include <sys/mman.h>
#include <sys/signalfd.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <poll.h>
#include <semaphore.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define REG46 32u
struct compartido46 {
    sem_t tarea, recibido, continuar;
    uint64_t solicitud, visible;
};
static const unsigned char marca46[8] = { 'D', 'B', '4', '6', 1, 0, 0, 0 };

static int cerrar46(int *fd)
{
    if (*fd < 0) return 0;
    int n = *fd; *fd = -1;
    if (close(n) == -1) { perror("close"); return -1; }
    return 0;
}
static void poner46(unsigned char *p, uint64_t n)
{
    for (unsigned i = 0; i < 8; ++i) { p[i] = (unsigned char)(n & 255u); n >>= 8; }
}
static uint64_t sacar46(const unsigned char *p)
{
    uint64_t n = 0;
    for (unsigned i = 0; i < 8; ++i) n |= (uint64_t)p[i] << (8u * i);
    return n;
}
static uint64_t checksum46(const unsigned char *p, size_t n)
{
    uint64_t h = UINT64_C(14695981039346656037);
    for (size_t i = 0; i < n; ++i) { h ^= p[i]; h *= UINT64_C(1099511628211); }
    return h;
}
static int sincronizar46(int fd)
{
    int r;
    do { r = fsync(fd); } while (r == -1 && errno == EINTR);
    return r;
}
static int guardar46(int fd, uint64_t secuencia, uint64_t valor)
{
    if (secuencia > 1) { errno = EINVAL; return -1; }
    unsigned char b[REG46];
    memcpy(b, marca46, 8); poner46(b + 8, secuencia);
    poner46(b + 16, valor); poner46(b + 24, checksum46(b, 24));
    size_t hechos = 0;
    while (hechos < sizeof b) {
        ssize_t n = pwrite(fd, b + hechos, sizeof b - hechos,
                           (off_t)(secuencia * REG46 + hechos));
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else { if (n == 0) errno = EIO; return -1; }
    }
    return sincronizar46(fd);
}
/* Solo este formato: base obligatoria y una actualizacion opcional. */
static int recuperar46(int fd, uint64_t *valor, int *cola)
{
    struct stat st;
    if (fstat(fd, &st) == -1) return -1;
    if (st.st_size < (off_t)REG46 || st.st_size > (off_t)(2 * REG46)) {
        errno = EBADMSG; return -1;
    }
    *cola = 0; *valor = 0;
    for (uint64_t secuencia = 0; secuencia < 2; ++secuencia) {
        unsigned char b[REG46];
        size_t hechos = 0;
        while (hechos < sizeof b) {
            ssize_t n = pread(fd, b + hechos, sizeof b - hechos,
                              (off_t)(secuencia * REG46 + hechos));
            if (n > 0) hechos += (size_t)n;
            else if (n == 0) break;
            else if (errno != EINTR) return -1;
        }
        if (hechos == 0 && secuencia == 1) return 0;
        if (hechos != sizeof b) {
            if (secuencia == 0) { errno = EBADMSG; return -1; }
            *cola = 1; return 0;
        }
        if (memcmp(b, marca46, 8) != 0 || sacar46(b + 8) != secuencia ||
            sacar46(b + 24) != checksum46(b, 24)) {
            errno = EBADMSG; return -1;
        }
        *valor = sacar46(b + 16);
    }
    return 0;
}
static int64_t ahora46(void)
{
    struct timespec t;
    if (clock_gettime(CLOCK_MONOTONIC, &t) == -1) return -1;
    return (int64_t)t.tv_sec * 1000 + t.tv_nsec / 1000000;
}
/* Espera breve con cancelacion. El plazo siempre es absoluto. */
static int pausa46(int control, int64_t fin)
{
    int64_t ahora = ahora46();
    if (ahora < 0) return -1;
    if (ahora >= fin) { errno = ETIMEDOUT; return -1; }
    int ms = fin - ahora > 50 ? 50 : (int)(fin - ahora);
    struct pollfd p = { .fd = control, .events = POLLIN };
    int r = poll(&p, 1, ms);
    if (r == -1) return errno == EINTR ? 0 : -1;
    if (p.revents & (POLLERR | POLLHUP | POLLNVAL)) { errno = EIO; return -1; }
    if (p.revents & POLLIN) {
        struct signalfd_siginfo s;
        ssize_t n = read(control, &s, sizeof s);
        if (n == -1 && (errno == EINTR || errno == EAGAIN)) return 0;
        if (n != (ssize_t)sizeof s) { errno = EIO; return -1; }
        errno = ECANCELED; return -1;
    }
    return 0;
}
static int esperar_sem46(sem_t *s, int control, int64_t fin)
{
    for (;;) {
        if (sem_trywait(s) == 0) return 0;
        if (errno == EINTR) continue;
        if (errno != EAGAIN || pausa46(control, fin) == -1) return -1;
    }
}
static int esperar_hijo46(pid_t hijo, int *estado, int control, int64_t fin)
{
    for (;;) {
        pid_t r = waitpid(hijo, estado, WNOHANG);
        if (r == hijo) return 0;
        if (r == -1 && errno == EINTR) continue;
        if (r == -1 || pausa46(control, fin) == -1) return -1;
    }
}
static int tomar46(sem_t *s)
{
    int r;
    do { r = sem_wait(s); } while (r == -1 && errno == EINTR);
    return r;
}
static int trabajador46(struct compartido46 *c, int fd, int seguro, int corte)
{
    if (tomar46(&c->tarea) == -1) return 2;
    if (seguro && guardar46(fd, 1, c->solicitud) == -1) { perror("guardar seguro"); return 3; }
    c->visible = c->solicitud;
    if (sem_post(&c->recibido) == -1) return 4;
    if (corte) return 50;  /* El llamador usa _exit: no ejecuta la continuacion. */
    if (tomar46(&c->continuar) == -1) return 4;
    if (!seguro && guardar46(fd, 1, c->solicitud) == -1) { perror("guardar anticipado"); return 3; }
    return 0;
}
int main(int argc, char **argv)
{
    if (argc != 3 || (strcmp(argv[1], "seguro") && strcmp(argv[1], "anticipado")) ||
        (strcmp(argv[2], "normal") && strcmp(argv[2], "corte"))) {
        fprintf(stderr, "Uso: %s seguro|anticipado normal|corte\n", argv[0]);
        return EXIT_FAILURE;
    }
    int seguro = strcmp(argv[1], "seguro") == 0, corte = strcmp(argv[2], "corte") == 0;
    sigset_t mascara;
    sigemptyset(&mascara); sigaddset(&mascara, SIGINT); sigaddset(&mascara, SIGTERM);
    if (signal(SIGCHLD, SIG_DFL) == SIG_ERR || sigprocmask(SIG_BLOCK, &mascara, NULL) == -1) {
        perror("senales"); return EXIT_FAILURE;
    }
    int control = -1, fd = -1, dirfd = -1, contenedor = -1;
    int salida = EXIT_FAILURE, inicializados = 0, recogido = 0, estado = 0;
    pid_t hijo = -1;
    struct compartido46 *c = MAP_FAILED;
    char dir[] = "./db46.XXXXXX", ruta[128];
    control = signalfd(-1, &mascara, SFD_NONBLOCK | SFD_CLOEXEC);
    if (control == -1 || mkdtemp(dir) == NULL) { perror("preparar"); goto fin; }
    printf("DB46 directorio=%s\n", dir);
    if (fflush(stdout) == EOF) goto fin;
    int largo = snprintf(ruta, sizeof ruta, "%s/diario.bin", dir);
    if (largo < 0 || (size_t)largo >= sizeof ruta) goto fin;
    contenedor = open(".", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
    dirfd = open(dir, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
    fd = open(ruta, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0600);
    if (contenedor == -1 || dirfd == -1 || fd == -1 || guardar46(fd, 0, 0) == -1 ||
        sincronizar46(dirfd) == -1 || sincronizar46(contenedor) == -1) {
        perror("base inicial"); goto fin;
    }
    c = mmap(NULL, sizeof *c, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (c == MAP_FAILED) { perror("mmap"); goto fin; }
    c->solicitud = 0; c->visible = 0;
    if (sem_init(&c->tarea, 1, 0) == -1) goto fin;
    inicializados = 1;
    if (sem_init(&c->recibido, 1, 0) == -1) goto fin;
    inicializados = 2;
    if (sem_init(&c->continuar, 1, 0) == -1) goto fin;
    inicializados = 3;
    int64_t fin_espera = ahora46();
    if (fin_espera < 0) goto fin;
    fin_espera += 7000;
    hijo = fork();
    if (hijo == -1) { perror("fork"); goto fin; }
    if (hijo == 0) {
        sigset_t vacia; sigemptyset(&vacia);
        if (signal(SIGINT, SIG_DFL) == SIG_ERR || signal(SIGTERM, SIG_DFL) == SIG_ERR ||
            sigprocmask(SIG_SETMASK, &vacia, NULL) == -1) _exit(2);
        if (cerrar46(&control) == -1 || cerrar46(&dirfd) == -1 || cerrar46(&contenedor) == -1) _exit(2);
        int codigo = trabajador46(c, fd, seguro, corte);
        if (cerrar46(&fd) == -1 && codigo == 0) codigo = 5;
        _exit(codigo);
    }
    c->solicitud = 7;
    if (sem_post(&c->tarea) == -1 || esperar_sem46(&c->recibido, control, fin_espera) == -1) {
        perror("publicacion"); goto fin;
    }
    uint64_t visible = c->visible, antes = 0, recuperado = 0;
    int cola = 0;
    if (recuperar46(fd, &antes, &cola) == -1 || cola) { perror("leer antes"); goto fin; }
    if (!corte && sem_post(&c->continuar) == -1) goto fin;
    if (esperar_hijo46(hijo, &estado, control, fin_espera) == -1) { perror("esperar hijo"); goto fin; }
    recogido = 1;
    if (!WIFEXITED(estado) || WEXITSTATUS(estado) != (corte ? 50 : 0)) {
        fprintf(stderr, "Estado de hijo inesperado\n"); goto fin;
    }
    if (recuperar46(fd, &recuperado, &cola) == -1) { perror("recuperar"); goto fin; }
    uint64_t esperado = corte && !seguro ? 0 : 7;
    if (visible != 7 || antes != (seguro ? 7u : 0u) || recuperado != esperado || cola) {
        fprintf(stderr, "Invariante del experimento incumplida\n"); goto fin;
    }
    printf("modo=%s escenario=%s visible=%" PRIu64 " diario_antes=%" PRIu64
           " recuperado=%" PRIu64 " cola_incompleta=%d hijo=%d\n",
           argv[1], argv[2], visible, antes, recuperado, cola, WEXITSTATUS(estado));
    if (fflush(stdout) == EOF) goto fin;
    salida = EXIT_SUCCESS;
fin:
    if (hijo > 0 && !recogido) {
        if (kill(hijo, SIGKILL) == -1 && errno != ESRCH) perror("kill propio");
        pid_t r;
        do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
        if (r != hijo) salida = EXIT_FAILURE;
    }
    /* Ya no hay otro participante que pueda estar esperando en los semaforos. */
    if (c != MAP_FAILED) {
        if (inicializados >= 3 && sem_destroy(&c->continuar) == -1) salida = EXIT_FAILURE;
        if (inicializados >= 2 && sem_destroy(&c->recibido) == -1) salida = EXIT_FAILURE;
        if (inicializados >= 1 && sem_destroy(&c->tarea) == -1) salida = EXIT_FAILURE;
        if (munmap(c, sizeof *c) == -1) salida = EXIT_FAILURE;
    }
    if (cerrar46(&fd) == -1) salida = EXIT_FAILURE;
    if (cerrar46(&dirfd) == -1) salida = EXIT_FAILURE;
    if (cerrar46(&contenedor) == -1) salida = EXIT_FAILURE;
    if (cerrar46(&control) == -1) salida = EXIT_FAILURE;
    return salida;
}

El traspaso está sincronizado: solicitud se escribe antes de publicar tarea, y visible se escribe antes de publicar recibido. Cada campo tiene un único escritor en la fase correspondiente. El semáforo continuar es una compuerta de observación, no una prueba de durabilidad.

Al fallar una espera o una operación interna, el padre termina y recoge al hijo antes de destruir los semáforos o desmontar la región. No intenta seguir usando una estructura cuyo protocolo quedó incompleto. Los archivos quedan en el directorio privado anunciado para inspección, incluso si falla una corrida.

10. Ejecutar y explicar los cuatro escenarios

Bash en Linux · compilar y ejecutar
gcc -std=c11 -Wall -Wextra -Wpedantic -O2 db46.c -o db46 -pthread
./db46 seguro normal
./db46 anticipado normal
./db46 seguro corte
./db46 anticipado corte

Cada ejecución anuncia su propio directorio nuevo. Conserva esa ruta si deseas inspeccionar el diario. Usa un directorio de trabajo sobre un sistema de archivos que implemente la sincronización solicitada; si alguna llamada fsync falla, el experimento falla. En tmpfs puede observarse el orden del programa, pero no se obtiene almacenamiento persistente frente a reinicio.

Modo y escenarioVisibleDiario antes de continuarRecuperado al finalCódigo del hijo
seguro normal.7.7.7.0.
anticipado normal.7.0.7.0.
seguro corte.7.7.7.50.
anticipado corte.7.0.0.50.

Estas cifras son estados esperados del protocolo, no tiempos de rendimiento. El padre retorna cero si observa exactamente el escenario solicitado. El código 50 del hijo es la salida inyectada esperada en corte; una salida diferente, un timeout o una invariante incumplida hacen fallar el programa.

La comparación importante es anticipado normal frente a anticipado corte. Ambos publicaron el mismo valor en memoria. Solo uno llegó a ejecutar la escritura posterior. Si el padre hubiera interpretado recibido como «commit durable», habría informado éxito con una garantía que el protocolo no cumple.

En seguro corte, la salida del hijo no elimina el registro que ya sincronizó. Esto comprueba que la recuperación del modelo no necesita volver a consultar la región compartida. No demuestra por sí solo comportamiento ante pérdida de energía: el proceso lector sigue utilizando el mismo núcleo y dispositivo.

Los directorios quedan disponibles para los ejercicios. Retira únicamente el archivo y el directorio de la corrida que hayas identificado, después de terminar todos sus participantes. El programa no reutiliza un diario viejo ni trunca archivos que el usuario hubiera creado antes.

11. Recuperar el diario desde otro proceso

Guarda leer46.py. Este lector abre un diario terminado en modo de solo lectura y reconstruye el último estado válido del formato del laboratorio. No se conecta a la región compartida, no interpreta el formato de un motor real y no modifica el archivo.

leer46.py · validación independiente del diario de dos registros
import argparse
import json
from pathlib import Path
import struct
import sys

MARCA = b"DB46\x01\x00\x00\x00"
TAM = 32
MASCARA = (1 << 64) - 1

def checksum(datos):
    h = 14695981039346656037
    for byte in datos:
        h = ((h ^ byte) * 1099511628211) & MASCARA
    return h

def recuperar(ruta):
    with ruta.open("rb") as archivo:
        datos = archivo.read(2 * TAM + 1)
    if not TAM <= len(datos) <= 2 * TAM:
        raise ValueError("tamano fuera del formato del laboratorio")
    completos, cola = divmod(len(datos), TAM)
    valor = 0
    secuencia = 0
    for esperado in range(completos):
        b = datos[esperado * TAM:(esperado + 1) * TAM]
        if b[:8] != MARCA:
            raise ValueError("cabecera o version invalida")
        numero, nuevo, suma = struct.unpack("<QQQ", b[8:])
        if numero != esperado or suma != checksum(b[:24]):
            raise ValueError("secuencia o checksum invalido")
        secuencia, valor = numero, nuevo
    return {"secuencia": secuencia, "valor": valor,
            "cola_incompleta_bytes": cola}

def main():
    p = argparse.ArgumentParser()
    p.add_argument("diario", type=Path)
    a = p.parse_args()
    print(json.dumps(recuperar(a.diario), sort_keys=True))

if __name__ == "__main__":
    try:
        main()
    except (ValueError, OSError) as error:
        print(error, file=sys.stderr)
        sys.exit(1)
Bash · reemplazar la ruta por la anunciada en una corrida terminada
python3 leer46.py ./db46.ABC123/diario.bin

El JSON informa valor, secuencia y cantidad de bytes de cola incompleta. Si solo está la base, devuelve valor cero y secuencia cero. Si el segundo registro está completo y válido, devuelve su valor. Una corrupción completa no se convierte silenciosamente en «no había actualización»: el lector devuelve error.

El código limita el archivo a 64 bytes porque ese es el formato cerrado del ejercicio. Un diario real necesita límites de segmento, versiones, identificación de base, posiciones y reglas para enlazar registros y transacciones. No sería correcto relajar ese límite y afirmar que ya se dispone de un WAL general.

Ejecuta la recuperación cuando el escritor haya terminado. El lector no implementa un snapshot concurrente del archivo. Una lectura de un archivo mientras cambia podría mezclar un tamaño anterior con bytes posteriores y requiere otro protocolo.

12. Caídas, errores de E/S y resultado desconocido

La frontera del fallo cambia lo que se pierde. Al salir el hijo del laboratorio, el padre conserva la región mapeada y el núcleo conserva sus cachés. Al desaparecer todos los participantes se pierde la región anónima. Al perder energía pueden perderse también cachés que todavía no cumplieron el contrato de sincronización.

Punto de falloQué sabe el solicitantePolítica necesaria
Antes de consumir la tarea.La tarea se publicó, pero puede no haberse ejecutado.Timeout, estado de trabajo e identidad para decidir reintento.
Durante la escritura del registro.Puede existir una cola incompleta.Framing y validación; no aplicar bytes parciales.
fsync informa error.No se confirmó la durabilidad solicitada.No anunciar éxito durable; preservar evidencia y tratar el fallo.
Después de sincronizar y antes de publicar respuesta.El cambio puede ser recuperable aunque el cliente no reciba éxito.Resultado desconocido e identificación estable de la operación.
Después de publicar antes de escribir, en anticipado.El lector vio 7; el diario puede seguir en cero.No confundir esa publicación con confirmación durable.

Un fallo de fsync no demuestra que ningún byte haya llegado al almacenamiento. Puede haber datos completos legibles y, aun así, no haberse confirmado la garantía requerida. Del mismo modo, no recibir una respuesta no demuestra que el servidor no haya confirmado internamente.

Por eso una recuperación y una deduplicación de solicitudes resuelven problemas distintos. El diario permite reconstruir estado; una identidad de operación permite reconocer un reintento y decidir si se vuelve a ejecutar o se consulta un resultado anterior. El tema 43 estudia esa incertidumbre desde el lado del cliente.

Los semáforos tampoco recuperan trabajo por sí solos. Si un consumidor desaparece después de tomar un permiso, no hay un «dueño» recuperable automáticamente para ese permiso. El ejemplo abandona toda la región tras el fallo; una cola de larga vida necesitaría estados verificables, generaciones y reparación coordinada.

Destruir un semáforo mientras otro proceso todavía lo espera no es una política de cancelación válida. Primero termina y recoge los participantes o completa un protocolo que confirme que nadie lo usa; después destruye la sincronización y desmonta la memoria.

13. Checkpoint y reutilización del diario

Si toda recuperación tuviera que empezar siempre desde el primer cambio histórico, su costo crecería sin límite. Un checkpoint establece una base desde la que recuperar con menos registros, de acuerdo con el protocolo del motor.

  1. Definir qué cambios abarca la base o punto de recuperación.
  2. Asegurar el diario necesario antes de escribir páginas que dependan de él.
  3. Completar y sincronizar las páginas y metadatos requeridos por el protocolo.
  4. Publicar de forma recuperable la información del checkpoint.
  5. Reutilizar únicamente registros que ya no necesita ningún consumidor ni recuperación retenida.

No se debe borrar un diario porque sus bytes ya se copiaron a memoria o porque una llamada write de páginas terminó. Todavía pueden faltar sincronización, metadatos del checkpoint, lectores antiguos, copias de seguridad o consumidores de replicación.

Mientras un escritor de páginas trabaja, nuevas consultas pueden volver a modificar un búfer. Limpiar su marca dirty sin relacionarla con la versión que efectivamente se escribió puede perder la indicación de una modificación posterior. La versión o posición del diario ayuda a razonar sobre esa carrera.

El ejemplo conserva la base y una actualización; no implementa checkpoint ni truncamiento. Para extenderlo habría que definir cómo publicar una nueva base de manera que, tras cualquier corte, quede una combinación recuperable de base, metadatos y diario. Un rename aislado no completa ese protocolo.

Un lote de confirmaciones puede compartir una sincronización: cada operación del lote espera hasta que la posición sincronizada cubre su registro. Esto puede reducir costo por operación, a cambio de introducir espera y gestión del lote. No permite confirmar registros que todavía queden fuera de la frontera sincronizada.

14. Relacionar el modelo con motores reales

La documentación de PostgreSQL sobre WAL presenta la recuperación mediante redo y la posibilidad de que una sincronización cubra varias transacciones. El diario del ejercicio sirve para observar el orden básico, pero no reproduce páginas, control de concurrencia ni el formato de recuperación de PostgreSQL.

Otro diseño se observa en SQLite en modo WAL: utiliza un WAL y un índice asociado para coordinar su acceso. Esa documentación describe sus condiciones de uso local y la coordinación de lectores, escritor y checkpoints. No hay que deducir que todas las bases usan un proceso servidor central o el mismo esquema de memoria compartida.

Idea del laboratorioCorrespondencia conceptualExtensión real necesaria
Una ranura compartida.Intercambio de estado entre participantes locales.Múltiples páginas, versiones, límites y protección.
Un consumidor del diario.Orden de publicación y de escritura.Coordinación de muchos productores y posiciones de avance.
Registro de estado completo.Información para reconstruir un valor.Operaciones de redo, transacciones y formatos versionados.
fsync antes de publicar.Confirmación condicionada a la sincronización.Configuración, almacenamiento, errores y otras políticas explícitas.
Lector independiente.Reconstrucción sin memoria de procesos anteriores.Recuperación completa desde una base consistente.

Cuando estudies un motor, identifica sus garantías y configuración concretas. «Usa memoria compartida» describe una técnica de comunicación; no determina un nivel de aislamiento ni una garantía de persistencia.

15. Simular publicación y pérdida de memoria

El simulador permite escribir un valor, publicar su visibilidad, escribir un registro pendiente y sincronizarlo. Puedes perder la memoria volátil en distintos puntos para separar lo visible de lo recuperable. Es un modelo de estados: no ejecuta fsync en el navegador ni prueba el almacenamiento del equipo.

Cambio preparado—

Visible a otro lector—

Registro pendiente en caché—

Estado durable del modelo—

Conocimiento del cliente—

Estado del servicio—

—

La política segura del simulador limita la confirmación, aunque permite mostrar la publicación de un valor antes de confirmar. «Visible» representa una publicación didáctica, no visibilidad SQL. La política anticipada permite confirmar sin sincronizar para exponer la diferencia de contratos.

Perder estado volátil descarta también el registro pendiente de caché. Eso modela un fallo más amplio que terminar al hijo del programa C. En el laboratorio corte, anticipado ni siquiera llegó a escribir ese registro: ambos ensayos enseñan órdenes posibles, con fronteras de fallo diferentes.

16. Observar IPC y almacenamiento por separado

Bash · trazar una ejecución propia
ensayo=$(mktemp -d)
strace -ff -tt -T -yy -s 64 -o "$ensayo/traza" -e trace=clone,clone3,mmap,munmap,futex,poll,signalfd4,openat,pwrite64,pread64,fsync,close,wait4,kill ./db46 seguro corte
# Repetir con anticipado corte y comparar el orden, no el rendimiento.

En seguro, el pwrite y fsync de la actualización preceden a la publicación recibido. Esa publicación puede no aparecer como una llamada propia: los semáforos pueden realizar operaciones de usuario y usar futex cuando hace falta esperar o despertar. No esperes una syscall sem_post por cada sem_post del código C.

mmap muestra la región compartida, pero no informa por sí solo qué campo es una tarea o qué valor se considera confirmado. El estado de aplicación se reconstruye relacionando la traza con el protocolo. El padre usa pread y el hijo pwrite para no depender de un desplazamiento de archivo compartido por fork.

El lector de diario responde una pregunta distinta de lsof: interpreta registros, mientras lsof relaciona procesos con referencias abiertas. La existencia y tamaño de diario.bin no prueban que su checksum sea correcto ni que se haya completado una sincronización.

Si mides tiempos, separa espera de cola, ejecución, escritura y sincronización. Un mejor promedio conseguido eliminando fsync compara contratos diferentes. Conserva el mismo nivel de confirmación y las mismas comprobaciones de recuperación antes de comparar rendimiento, siguiendo el tema 44.

17. Pruebas de integridad, orden y fallos

PruebaResultado esperadoPropiedad
Los cuatro modos del cuadro.Valores y código del hijo coinciden con el contrato.Orden de publicación y escritura.
Lector externo después de cada corrida.Coincide con recuperado del padre.Recuperación sin el mapeo compartido.
pwrite y pread reales de un byte con EINTR.Registro completo y valor correcto.Desplazamientos y reintentos sin progreso ficticio.
Cortar el segundo registro después de algunos bytes.Base cero y cola incompleta informada.No aplicar un registro parcial.
Cambiar un byte de un registro completo.Error de recuperación.Checksum, cabecera y secuencia validados.
Base ausente o incompleta.Error; no inventar una base válida.Precondiciones de recuperación.
Registro adicional o secuencia incorrecta.Error del formato cerrado.No aceptar un diario diferente por accidente.
Fallar el fsync de la actualización en seguro.No publicar recibido; el padre falla y recoge al hijo.No anunciar la garantía que falló.
Hijo detenido antes de publicar.Vence el límite del padre, termina al hijo y lo recoge.Una espera de semáforo no bloquea para siempre al supervisor.
Fallo de fork o sem_init parcial.Solo se destruyen recursos realmente creados.Inventario y limpieza de arranque.

Preparar archivos de prueba sin tocar el original

Copia un diario válido a un directorio temporal propio y trabaja sobre esa copia. Para una cola parcial, conserva los primeros 32 bytes y de uno a 31 bytes del segundo registro. Para corrupción completa, conserva el tamaño y altera un byte sin recalcular el checksum. El lector debe distinguir ambos casos.

Repite también con un checksum recalculado y una secuencia equivocada: así compruebas que no se valida solo la suma. La validación independiente necesita comprobar formato, orden y contenido, no únicamente que el archivo tenga múltiplos de 32 bytes.

Una inyección de error debe elegir el fsync de la actualización, no alguno de los tres pasos de preparación inicial. En una copia instrumentada, distingue fd y fase o cuenta las llamadas conocidas. Reduce el plazo en esa copia para no convertir el ensayo de fallo en una espera larga.

Para el almacenamiento real, usa un entorno de pruebas controlado con una frontera de fallo definida. Matar un proceso o volver a abrir el mismo archivo solo verifica parte del protocolo. No interpretes ese ensayo como una certificación de resistencia del dispositivo a pérdida de energía.

18. Errores frecuentes y decisiones de diseño

ErrorConsecuenciaRegla de diseño
Equiparar MAP_SHARED con persistencia.Se pierde estado que se suponía durable.Definir respaldo, sincronización y recuperación.
Usar volatile como publicación.Datos sin orden o protección adecuados.Protocolo sincronizado con propietarios claros.
Guardar punteros privados en una cola.El consumidor interpreta otra dirección.Índices o desplazamientos validados.
Confundir pin y exclusión de escritura.Se evita reemplazo pero persiste una carrera de contenido.Separar referencias de uso y protección de bytes.
Marcar dirty como si fuera commit.Se anuncia una garantía no establecida.Relacionar estado lógico, diario y confirmación.
Confirmar tras write sin comprobar fsync.Éxito anticipado al contrato durable.Comprobar la sincronización requerida y sus errores.
Destruir semáforos con participantes activos.Uso inválido y esperas sin protocolo.Parar, recoger y después destruir.
Recuperar una struct nativa de C.Dependencia de padding, arquitectura y versión.Formato explícito, límites y validación.
Ignorar corrupción completa como si fuera EOF.Se oculta daño y se recupera un estado engañoso.Distinguir fin limpio, cola parcial y registro inválido.
Eliminar WAL antes de fijar una base recuperable.Faltan registros necesarios tras un fallo.Checkpoint y retención con orden comprobable.

Una revisión útil sigue una actualización completa: quién reserva la tarea, quién escribe la página, qué protege sus bytes, dónde se registra, qué se sincroniza y qué evento permite confirmar. Después repite ese recorrido suponiendo una caída entre cada par de pasos.

La cola y el diario tienen funciones diferentes. La cola indica trabajo que puede estar pendiente; el diario determina información de recuperación bajo sus reglas. Borrar una tarea terminada no autoriza a borrar el registro que todavía necesita un checkpoint.

19. Resumen, repaso y práctica

La memoria compartida reduce copias, la sincronización protege transiciones y las colas distribuyen trabajo. La persistencia necesita otro protocolo: formato recuperable, orden de escritura y comprobación de sincronización. Ver un valor y poder reconstruirlo después de un fallo son afirmaciones diferentes.

Preguntas de repaso

1. ¿Qué resuelve la memoria compartida?

Permite acceder a un estado común sin copiarlo en cada mensaje. No establece por sí sola exclusión, aislamiento ni persistencia.

2. ¿Por qué un puntero privado no sirve como referencia de cola?

Las direcciones virtuales pertenecen a cada proceso. Se usan índices o desplazamientos validados dentro de una región acordada.

3. ¿Un pin impide que cambien los bytes de una página?

Su función conceptual es impedir reemplazo mientras se usa la ranura. La protección de contenido necesita reglas adicionales.

4. ¿Dirty significa durable?

No. Indica una diferencia pendiente respecto del respaldo; no confirma sincronización ni visibilidad lógica.

5. ¿Un mutex proporciona aislamiento de transacciones?

No por sí solo. Protege una región o estructura; el aislamiento necesita reglas para lecturas, escrituras y conflictos a nivel de transacción.

6. ¿Qué garantiza el semáforo recibido del programa?

Que el hijo publicó el campo visible. En seguro, el protocolo exige además haber sincronizado antes; en anticipado esa garantía no existe.

7. ¿Por qué existe continuar?

Permite observar el diario antes de la escritura pendiente del modo anticipado, sin depender de tiempos aproximados.

8. ¿Qué diferencia seguro corte de anticipado corte?

Ambos publican 7, pero solo seguro sincroniza su registro antes. Sus estados recuperados son 7 y cero, respectivamente.

9. ¿write exitoso prueba durabilidad?

No. Los bytes pueden permanecer en cachés volátiles. Hay que cumplir y comprobar el protocolo de sincronización requerido.

10. ¿Por qué sincronizar el directorio de un archivo nuevo?

Porque sincronizar el archivo no garantiza por sí solo que su entrada de directorio haya quedado persistida.

11. ¿El checksum hace que una escritura sea atómica?

No. Sirve para validar registros; no impide una escritura parcial ni sustituye el orden de confirmación.

12. ¿Qué hace el lector con una cola incompleta?

La informa y conserva el último estado completo válido. Una base incompleta o un registro completo corrupto producen error.

13. ¿Matar al hijo reproduce un apagón?

No. El padre y las cachés del núcleo siguen existiendo. La frontera de fallo del ensayo es más pequeña.

14. ¿Qué puede pasar si se pierde la respuesta después de fsync?

El estado puede ser recuperable mientras el cliente desconoce el resultado. Un reintento requiere identidad y reglas de idempotencia.

15. ¿Cuándo puede reutilizarse un registro del diario?

Cuando las reglas de checkpoint, recuperación y otros consumidores ya no lo requieren. No basta haberlo copiado a memoria.

Para practicar y ampliar

  1. Dibuja las transiciones de los tres semáforos y el dueño de cada campo.
  2. Ejecuta los cuatro escenarios y explica sus diferencias sin usar el tiempo como argumento.
  3. Recupera cada diario desde leer46.py después de terminar el programa C.
  4. Fuerza pwrite y pread reales de un byte con interrupciones EINTR.
  5. Construye copias con todas las longitudes posibles de cola parcial.
  6. Altera cabecera, secuencia, valor y checksum, verificando el rechazo esperado.
  7. Inyecta un error de fsync antes de la publicación segura.
  8. Detén al consumidor y verifica que el padre no espera indefinidamente.
  9. Propón una cola con varios productores, generaciones y recuperación de reservas.
  10. Diseña un mensaje que distinga aceptado, ejecutado y confirmado durable.
  11. Propón un checkpoint que sobreviva a un corte entre cada par de pasos.
  12. Compara confirmación por operación y por lote conservando la misma garantía.
Próximo paso

El tema 47 estudia IPC en arquitecturas de microservicios: sockets Unix entre servicios del mismo host y el paso a TCP cuando la comunicación cruza máquinas.