SERVICIOS POSIX RELACIONADOS CON LA

COMUNICACIÓN Y SINCRONIZACION DE

PROCESOS

INTEGRANTES

Kevin Alexander Alvarado Ayala Nathaly Adelina Gutierrez Saravia Sandra Beatriz Morales Martinez Karla Estefany Soto Regalado

¿Qué es POSIX?

Tuberías Una tubería es un mecanismo de comunicación y

sincronización. El flujo de datos en la comunicación empleando tuberías

es unidireccional y FIFO. La Figura representa dos procesos que se comunican de forma unidireccional utilizando una tubería.

En POSIX existen tuberías sin nombre, o simplemente pipes, y tuberías con nombre, o FIFOS.

Tuberías Crear una tubería sin nombre Este servicio permite crear una tubería. Su prototipo es el

siguiente:Int pipe (int fildes[2]);

Crear una tubería con nombreEn POSIX las tuberías con nombres se conocen como FIFO.

Los FIFOS tienen un nombre local que lo identifican dentro de una misma máquina. El prototipo del servicio que permite crear una tubería con nombre el siguiente.

Int mkfifo (char*fifo, mode_t mode);

Tuberías Abrir una tubería con nombre El servicio que permite abrir una tubería con nombre es

open. Este servicio también se emplea para abrir archivos. Su prototipo es el siguiente:

Int open (char*fifo, int flag); Cerrar una tubería Este servicio open cierra un descriptor de archivo asociado a

una tubería con o sin nombre. También se emplea para cerrar cualquier archivo. Su prototipo es:

Int close (int fd);

Tuberías Borrar una tubería Permite borrar un FIFO. Esta llamada también se emplea

para borrar archivo. Su protocolo es:Int unlink(char*fifo);

Leer de una tubería Para leer datos de un pipe o un FIFO se utiliza el siguiente

servicio:Int read(int fd , char * buffer, int n);

Tuberías Borrar una tubería Permite borrar un FIFO. Esta llamada también se emplea

para borrar archivo. Su protocolo es:Int unlink(char*fifo);

Escribir en una tubería El servicio para escribir datos en una tubería en POSIX es:

Int write (int fd, char *buffer, int n);

Tuberías Productor-consumidor con tuberías El siguiente programa muestra un fragmento de ejemplo que

se puede para resolver problemas de tipo productor-consumidor mediante las tuberías que ofrece POSIX. En este ejemplo se crea un proceso hijo por medio de la llamada fork. A continuación, el proceso hijo hará las veces de productor y el proceso padre de consumidor.

Semáforos POSIX Un semáforo es un mecanismo de sincronización

que se utiliza generalmente en sistemas con memoria compartida, bien sea un monoprocesador o un multiprocesador.

Las operaciones wait y signal son dos operaciones genéricas que deben particularizarse en cada sistema operativo.

Semáforos POSIX En POSIX un semáforo se identifica mediante una

variable del tipo sem_t. El estándar POSIX define dos tipos de semáforos:

•Semáforos sin nombre. •Semáforos con nombre.

Semáforos POSIX Los servicios POSIX para manejar semáforos son los

siguientes:

Crear un semáforo sin nombreTodos los semáforos en POSIX deben iniciarse antes de

su uso. La función sem_init permite iniciar un semáforo sin nombre. El prototipo de este servicio es el siguiente:

Int sem_init(sem_t *sem, int shared, int val);

Semáforos POSIX Destruir un semáforo sin nombreCon este servicio se destruye un semáforo sin nombre previamente

creado con la llamada sem_init. Su prototipo es el siguiente:Init sem_destroy(sem_t *sem);

Crear y abrir un semáforo con nombreEl servicio sem_open permite crear o abrir un semáforo con nombre. Estas modalidades son las siguientes:

Sem_t *sem_open(char *name, int flag, mode_t mode, int val);Sem_t *sem_open(char *name, int flag);

Semáforos POSIX Cerrar un semáforo con nombreCierra un semáforo con nombre, rompiendo la asociación que tenía

un proceso con un semáforo. El prototipo de la función es:Int sem_close(sem_t *sem);

Borrar un semáforo con nombreElimina del sistema un semáforo con nombre. Esta llamada pospone

la destrucción de semáforo hasta que todos los procesos que lo estén utilizando lo hayan cerrado con la función sem_close. El prototipo de este servicio es:

Int sem_unlink(char *name);

Semáforos POSIX Operación waitLa operacion wait en POSIX se consigue con el siguiente servicio:

Int sem_wait(sem_t *sem);

Operacion signalEste servicio se corresponde con la operación signal sobre un

semáforo. El prototipo de este servicio es:Int sem_post(sem_t *sem);

Mutex y variables condicionales en POSIX Para utilizar un mutex un programa debe declarar una variable de

tipo pthread_mutex_t (definido en el archivo de cabecera pthread.h) e iniciarla antes de utilizarla.

 Iniciar un mutexEsta función permite iniciar una variable de tipo mutex. Su prototipo

es el siguiente:Int pthread_mutex_init(pthread_mutex_t *mutex, Pthread_mutexattr_t *attr);

Mutex y variables condicionales en POSIX Destruir un mutexPermite destruir un objeto de tipo mutex. El prototipo de la función

que permite invocar este servicio es:Int pthread_mutex_destroy(pthread_mutex_t *mutex);

  Operacion unlockEste servicio se corresponde con la operacion unlock y permite al

proceso ligero que la ejecuta liberar el mutex. El prototipo es:Int pthread_cond_init(pthread_cond_t *cond, Pthread_condattr_t *attr);

Mutex y variables condicionales en POSIX Destruir una variable condicionalPermite destruir una variable de tipo condicional. Si prototipo es:

Int pthread_cond_destroy (pthread_cond_t *cond);  Operación c_Wait sobre una variable condicional Este servicio corresponde con la operación c_Wait sobre una variable

condicional. Su prototipo es: Int pthread_cond_wait(pthread_cond_t *cond, Pthread_mutex_t_*mutex);

Mutex y variables condicionales en POSIX Operación c_signal sobre una variable condicionalEste servicio se corresponde con la operación c_signal sobre una

variable condicional. Su pronto tipo es:Int pthread_cond_signal(pthread_cond_t *cond);Para desbloquear a todos los procesos ligeros suspendidos en una

variable condicional se emplea el servicio: Int pthread_cond_broadcast(pthread_cond_t *cond);

Colas de mensajes POSIX Las cola de mensajes POSIX son un mecanismo de comunicación

y sincronización que pueden utilizar los procesos que ejecutan en la misma máquina, bien sea un multiprocesador o una multicomputadora.

Crear y abrir una cola de mensajes Existen dos modalidades con las que se puede invocar a esta

función según se quiere crear o simplemente abrir una cola ya existente:

Mqd_t mq_open (char *name, int flag, mode_t mode, Struct mq_attr *attr);Mqd_t mq_open(char *name, int flag);

Colas de mensajes POSIX Cerrar una cola de mensajesCierra una cola de mensajes. El prototipo de la función que permite

invocar este servicio es:Int mq_close(mqd_t mqdes);

Borrar una cola de mensajesBorra una cola de mensajes. Su prototipo es:

Int mq_unlink(char*name); Enviar datos a una cola de mensajesPermite enviar un mensaje a una cola de mensajes. Su prototipo es

el siguiente:Int mq_send(mqd_t mqdes, char*msg, size_t len, int prio);

Colas de mensajes POSIX Recibir datos de una cola de mensajes Permite recibir un mensaje de una cola de mensajes. El prototipo que

permite invocar este servicio es: Int mq_receive(mqd_t mqdes, char*msg, size_t len, int *prio);

Asignar atributos a una cola de mensajes Permite cambiar los atributos asociados a una cola de mensajes. Su

prototipo es:Int mq_setattr(mqd_t mqdes, struct mq_attr *qstat, Struct mq_attr *oldmqstat);

Colas de mensajes POSIX Obtener los atributos de una cola de mensajesDevuelve los atributos de una cola de mensajes. Su prototipo es el

siguiente:Int mq_getattr(mqd_t mqdes, struct mq_attr *qstat);