Sistemas Operativos 2025_2 Course Materials & Test Answers | grado.pol.una.py

Comunicación Bidireccional con Tuberías (Pipes)

Lee cuidadosamente el siguiente código, que implementa una comunicación unidireccional entre un proceso padre y un proceso hijo utilizando una tubería ordinaria.

Se desea modificar el programa para agregar una segunda tubería que permita comunicación bidireccional. El hijo debe responder al padre con el mensaje: "Bien, gracias".

¿Cuál de las siguientes opciones implementa CORRECTAMENTE la respuesta del hijo al padre usando una segunda tubería?

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <sys/wait.h>

#define BUFFER_SIZE 256

int main() {

int fd[2];

pid_t pid;

char mensaje[] = "Hola hijo, ¿cómo estás?";

char buffer[BUFFER_SIZE];

if (pipe(fd) == -1) {

perror("pipe");

exit(EXIT_FAILURE);

}

pid = fork();

if (pid < 0) {

perror("fork");

exit(EXIT_FAILURE);

}

if (pid > 0) { // Padre

close(fd[0]); // Cierra extremo de lectura

write(fd[1], mensaje, strlen(mensaje) + 1);

close(fd[1]);

wait(NULL);

} else { // Hijo

close(fd[1]); // Cierra extremo de escritura

read(fd[0], buffer, BUFFER_SIZE);

printf("Hijo recibió: %s\n", buffer);

close(fd[0]);

exit(EXIT_SUCCESS);

}

return 0;

}

Ninguna de las opciones resuelve

Agregar después de la creación del primer pipe:

int fd2[2];
pipe(fd2);
En el padre, después de wait(NULL):
close(fd2[1]);
char respuesta[BUFFER_SIZE];
read(fd2[0], respuesta, BUFFER_SIZE);
printf("Padre recibió: %s\n", respuesta);
close(fd2[0]);
En el hijo, antes de exit(EXIT_SUCCESS):
close(fd2[0]);
char resp[] = "Bien, gracias";
write(fd2[1], resp, strlen(resp) + 1);
close(fd2[1]);

Agregar después de la creación del primer pipe:

if (pipe(fd2) == -1) {
    perror("pipe");
    exit(EXIT_FAILURE);
}
En el padre, después de close(fd[1]) y antes de wait(NULL):
close(fd2[1]);
char respuesta[BUFFER_SIZE];
read(fd2[0], respuesta, BUFFER_SIZE);
printf("Padre recibió: %s\n", respuesta);
close(fd2[0]);
En el hijo, después de printf("Hijo recibió: ...") y antes de close(fd[0]):
close(fd2[0]);
char resp[] = "Bien, gracias";
write(fd2[1], resp, strlen(resp) + 1);
close(fd2[1]);

Agregar en el padre después de wait(NULL):

char respuesta[BUFFER_SIZE];
int fd2[2];
pipe(fd2);
read(fd2[0], respuesta, BUFFER_SIZE);
printf("Padre recibió: %s\n", respuesta);
close(fd2[0]);
Y en el hijo antes de exit(EXIT_SUCCESS):
char resp[] = "Bien, gracias";
write(fd2[1], resp, strlen(resp) + 1);
close(fd2[1]);

Agregar después de la creación del primer pipe:

int fd2[2];
if (pipe(fd2) == -1) {
    perror("pipe");
    exit(EXIT_FAILURE);
}
En el padre, después de write(fd[1], ...) y antes de close(fd[1]):
close(fd2[1]);
char respuesta[BUFFER_SIZE];
read(fd2[0], respuesta, BUFFER_SIZE);
printf("Padre recibió: %s\n", respuesta);
close(fd2[0]);
En el hijo, después de read(fd[0], ...) y antes de close(fd[0]):
close(fd2[0]);
char resp[] = "Bien, gracias";
write(fd2[1], resp, strlen(resp) + 1);
close(fd2[1]);

❌

View this question

Problema del productor-consumidor con buffer acotado:

El siguiente código muestra una implementación en pseudocódigo estilo C. Asume que semWait decrementa el semáforo y bloquea si el valor es negativo, y semSignal lo incrementa y desbloquea un proceso si hay alguno esperando.

Este programa puede llevar a una situación de interbloqueo (deadlock)? si es así, indica cuál sería la solución?

// Declaraciones globales
#define BUFFER_SIZE 5       // Tamaño máximo del buffer
semaphore mutex = 1;       // Semáforo para exclusión mutua al acceder al buffer [2]
semaphore full = 0;        // Semáforo que cuenta el número de elementos en el buffer [2]
semaphore empty = BUFFER_SIZE; // Semáforo que cuenta el número de espacios vacíos en el buffer [2]
item buffer[BUFFER_SIZE];  // Buffer circular compartido
int in = 0, out = 0;       // Punteros para la gestión del buffer circular
// Función para simular la producción de un elemento
item generate_item() {
    // Simula la producción
    return some_data;
}
// Función para simular el consumo de un elemento
void consume_item(item data) {
    // Simula el consumo
}
// Proceso Productor
void productor() {
    item next_produced;
    while (TRUE) {
        next_produced = generate_item(); // Paso 1: Producir un elemento
        semWait(empty);    // Paso 2: Esperar si el buffer está lleno (no hay espacios vacíos) [2]
        semWait(mutex);    // Paso 3: Entrar en la sección crítica para acceder al buffer [2, 6]
        // Sección crítica: añadir elemento al buffer
        buffer[in] = next_produced;
        in = (in + 1) % BUFFER_SIZE;
        // Fin de la sección crítica
        semSignal(mutex); // Paso 4: Salir de la sección crítica [2]
        semSignal(full);   // Paso 5: Indicar que hay un elemento más en el buffer [2]
    }
}
// Proceso Consumidor
void consumidor() {
    item next_consumed;
    while (TRUE) {
        semWait(mutex);    // <--- LÍNEA CON ERROR POTENCIAL (Paso 1 del Consumidor)
        semWait(full);     // Paso 2: Esperar si el buffer está vacío (no hay elementos llenos) [2]
        // Sección crítica: extraer elemento del buffer
        next_consumed = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        // Fin de la sección crítica
        semSignal(mutex);  // Paso 3: Salir de la sección crítica [2]
        semSignal(empty);  // Paso 4: Indicar que hay un espacio vacío más en el buffer [2]
        consume_item(next_consumed); // Paso 5: Consumir el elemento
    }
}
void main() {
    // Inicializar semáforos (ya hecho en las declaraciones globales)
    // Lanzar procesos Productor y Consumidor en paralelo
    paralelos(productor, consumidor); // Función hipotética para ejecutar hilos/procesos
}

Eliminar por completo las llamadas a semWait(mutex) y semSignal(mutex) de ambas funciones, productor y consumidor, ya que los semáforos full y empty ya controlan el acceso al buffer, haciendo mutex redundante.

Cambiar la inicialización de los semáforos a semaphore full = BUFFER_SIZE; y semaphore empty = 0;. Esto invertiría los roles de los semáforos, permitiendo que el consumidor siempre acceda primero.

Intercambiar el orden de semWait(empty) y semWait(mutex) en la función productor. La secuencia correcta de operaciones semWait en el productor debe ser semWait(mutex) seguida de semWait(empty).

El código original es correcto y no necesita ajustes. El sistema operativo gestiona automáticamente los bloqueos de los semáforos, evitando el interbloqueo y las condiciones de carrera.

Intercambiar el orden de semWait(mutex) y semWait(full) en la función consumidor. La secuencia correcta de operaciones semWait debe ser semWait(full) seguida de semWait(mutex).

View this question

Crowdly

Sistemas Operativos 2025_2

Want instant access to all verified answers on grado.pol.una.py?