Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 30 vistas

    tarea3SISTEMA OPERATIVO

    Cargado por

    Estefania Rodriguez Sanchez
    El problema involucra productores que generan datos y los colocan en un buffer, y un consumidor que extrae los datos del buffer de forma individual. Se debe evitar la superposición de operaciones sobre el buffer de tamaño finito. El pseudocódigo resuelve esto usando semáforos para coordinar el acceso al buffer entre los procesos productor y consumidor.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd

    tarea3SISTEMA OPERATIVO

    Cargado por

    Estefania Rodriguez Sanchez
    30 vistas6 páginas
    El problema involucra productores que generan datos y los colocan en un buffer, y un consumidor que extrae los datos del buffer de forma individual. Se debe evitar la superposición de operaciones sobre el buffer de tamaño finito. El pseudocódigo resuelve esto usando semáforos para coordinar el acceso al buffer entre los procesos productor y consumidor.

    Descripción original:

    CURSO DE SISTEMA OPERATIVO

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    DOC, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    El problema involucra productores que generan datos y los colocan en un buffer, y un consumidor que extrae los datos del buffer de forma individual. Se debe evitar la superposición de operaciones sobre el buffer de tamaño finito. El pseudocódigo resuelve esto usando semáforos para coordinar el acceso al buffer entre los procesos productor y consumidor.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd
    Descargar como doc, pdf o txt
    30 vistas6 páginas

    tarea3SISTEMA OPERATIVO

    Cargado por

    Estefania Rodriguez Sanchez
    El problema involucra productores que generan datos y los colocan en un buffer, y un consumidor que extrae los datos del buffer de forma individual. Se debe evitar la superposición de operaciones sobre el buffer de tamaño finito. El pseudocódigo resuelve esto usando semáforos para coordinar el acceso al buffer entre los procesos productor y consumidor.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd
    Descargar como doc, pdf o txt
    de 6

    Consorcio Clavijero

    Sistema Operativo.

    Alumna: Estefanía Rodríguez Sánchez.

    Facilitadora: Arturo Mendoza Rendón.

    Carrera: Ingeniería en sistemas

    computacionales.

    Ciclo:11.

    Tarea 3. Programación concurrente.

    Fecha:11 de febrero del 2024.


    Consorcio Clavijero

    Actividad 5 Programación concurrente


    Ingeniería en sistemas computacionales Ciclo IX
    Módulo II Sistemas operativos

    Nombre del alumno: Estefania Rodriguez Sanchez.

    Indicaciones: El estudiante, de manera individual, analizará un problema típico de la programación


    concurrente: el problema del productor/consumidor y elaborará en pseudocódigo (pueden utilizar
    variantes del lenguaje C o PASCAL) el algoritmo de solución utilizando semáforos.

    El problema es el siguiente:

    Uno o más productores generan cierto tipo de datos (registros, caracteres) y los sitúan en un
    buffer. Un único consumidor saca elementos del buffer de uno en uno. El sistema está obligado a
    impedir la superposición de operaciones sobre el buffer. Supóngase que el buffer es limitado y que
    consiste en un vector lineal de elementos.

    Uno o más productores generan cierto tipo de datos (registros, caracteres) y los
    sitúan en un buffer. Un único consumidor saca elementos del buffer de uno en uno.
    El sistema está obligado a impedir la superposición de operaciones sobre el buffer.
    Supóngase que el buffer es limitado y que consiste en un vector lineal de
    elementos.

    Los procesos comparten recursos que se necesitan previamente coordinar para que
    realicen sus acciones. Por ejemplo, se realizan dos procesos que son el productor y
    consumidor, Ambos son incluidos en un búfer de tamaño infinito. Los productores envían
    mensajes que son recibidos por los consumidores. Algunos mecanismos de
    comunicación y sincronización son los archivos, tuberías, llamadas al sistema para la
    gestión de tuberías, semáforos y las llamadas al sistema para la gestión de semáforos.
    El problema está en lograr que cuando el consumidor trata de extraer un ítem cuando el
    buffer está vacío, el consumidor se bloquee hasta que el productor deposite un ítem. Del
    mismo modo, cuando el productor intenta depositar un ítem cuando el buffer ya tiene el
    máximo de N ítems, el productor se debe bloquear hasta que el consumidor extraiga un
    ítem.

    La interconexión entre los puertos de la tarjeta principal y los módulos auxiliares que
    permiten el control de la intersección, que son: la tarjeta para la detección de los
    vehículos de emergencia, la tarjeta Ethernet para la comunicación con la central remota,
    Consorcio Clavijero

    la visualización con la pantalla LCD y la tarjeta de potencia que permite el encendido de


    las luces del semáforo y la detección de las fallas que se puedan presentar.
    Con un microcontrolador en la tarjeta principal, se programarán todos los tiempos de
    duración de las luces de los semáforos de la intersección, aunque pueden ser
    modificados por la central de monitoreo a través de la comunicación basada en TCP/IP,
    mediante una tarjeta Serial Ethernet.

    La comunicación entre la tarjeta principal y la tarjeta Ethernet se divide en dos rutinas: la


    rutina principal y la rutina de recepción/transmisión.
    La central de monitoreo permite visualizar el estado de las luces de la intersección de
    forma remota, así como la administración de los tiempos de las luces verdes y rojas de la
    intersección. Además, desde la central es posible establecer la fecha y hora de las
    notificaciones desde el servidor y el controlador de tráfico ubicado en la intersección.
    Rutina de recepción/transmisión recibe las tramas provenientes de la central de
    monitoreo y transmite los informes hacia la misma usando el protocolo TCP/IP, si se
    presenta una falla se soluciona en un controlador de tráfico, a través de esta rutina se
    informa a la central para que suspendan las rutinas de seguridad y se inicie, lo antes
    posible, el funcionamiento normal de los semáforos de la intersección.
    Módulo de potencia por medio de esta etapa se transforman los estados lógicos
    provenientes de la tarjeta principal, a los niveles de corriente alterna manejados por las
    luces de los semáforos (120 VAC) bombillos halógenos, incandescentes y de LED.

    Comunicación entre el Productor – Consumidor.

     Los productores envían mensajes que son recibidos por el consumidor.


     El consumidor saca elementos cuando el buffer está vacío.
     El productor coloca elementos en el buffer cuando este se encuentra lleno.
     El productor sobre escribe un elemento que todavía no se ha sacado del
    Consorcio Clavijero

    buffer.
     El consumidor saca elementos del buffer que ya fueron sacados con
    anterioridad.
     El consumidor saca un elemento mientras el productor lo está insertando

    Productores - Consumidores
    #include <iostream>
    #include <pthread.h>
    #include <semaphore.h>
    using namespace std ;

    sem_t//semaforos
    puede_escribir,// inicializado a 1
    puede_leer, // inicializado a 0
    acceder_buffer; //exclusion mutua

    int pos_r=0 ; // posicion donde leer


    int pos_w=0; // posicion donde escribir
    int v[10] ; // buffer
    int num_item=50;
    static int contador=0;

    int producir_dato()
    {
    return contador ++;
    }
    void consumir_dato(int dato)
    {
    cout<<"Dato recibidos: "<<dato<<endl;
    }

    void* productor( void* p )


    {
    for(unsigned i=0; i<num_item; i++)
    {

    sem_wait( &puede_escribir);//esperamos que pueda escribir y acceder al buffer


    sem_wait( &acceder_buffer) ;
    int dato=producir_dato();
    v[pos_w]=dato;
    //cout<<"La posicion write es: "<<pos_w<<endl;
    pos_w++;
    if(pos_w>=10)//incrementamos pos_W
    pos_w=pos_w%10;
    sem_post(&acceder_buffer) ;//permimitimos que pueda leer.
    sem_post(&puede_leer) ;
    }
    return NULL;
    Consorcio Clavijero

    void* consumidor( void* p )


    {
    for(unsigned i=0; i<num_item; i++)
    {
    int dato;

    sem_wait( &puede_leer) ;//esperamos que pueda leer y acceder al buffer


    sem_wait( &acceder_buffer) ;

    dato=v[pos_r];
    //cout<<"La posicion read es: "<<pos_r<<endl;
    pos_r++;
    if(pos_r>=10)
    pos_r=pos_r%10;//decrementamos pos_r

    sem_post( &acceder_buffer) ;//permitimos que pueda escribir


    sem_post( &puede_escribir) ;

    consumir_dato(dato);
    }
    return NULL ;
    }

    int main()
    {
    pthread_t hebra_escritora, hebra_lectora ;//creamos una hebra para leer y otra para
    escribir
    sem_init( &puede_escribir, 0, 10); // inicialmente se puede escribir
    sem_init( &puede_leer,0, 0); // inicialmente no se puede leer
    sem_init( &acceder_buffer,0,1);

    //Creamos las hebras


    pthread_create( &hebra_escritora, NULL, productor, NULL );
    pthread_create( &hebra_lectora,NULL,consumidor,NULL );

    //lanzamos las hebras


    pthread_join( hebra_escritora, NULL ) ;
    pthread_join( hebra_lectora,NULL ) ;

    //Destruimos los semaforos


    sem_destroy( &puede_escribir );
    sem_destroy( &puede_leer );
    sem_destroy( &acceder_buffer);

    return 0;
    }
    Consorcio Clavijero

    Referencias
    Gómez, N. A. (2022). Programación concurrente. Obtenido de
    https://www.pragma.com.co/academia/lecciones/programacion-concurrente-parte-1

    Team, K. (4 de diciembre de 2023). ¿Qué es la programación concurrente?. Obtenido de


    https://keepcoding.io/blog/que-es-la-programacion-concurrente/

    Unir, V. (21 de abril de 2023). La programación concurrente y su utilidad actual y futura. Obtenido
    de https://www.unir.net/ingenieria/revista/programacion-concurrente/

    También podría gustarte