Матеріали курсу Sistemas Operativos 2025_2 та відповіді на тести | grado.pol.una.py

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).

Переглянути це питання

Crowdly

Sistemas Operativos 2025_2

Хочете миттєвий доступ до всіх перевірених відповідей на grado.pol.una.py?