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/