capítulo 5 comunicación y sincronización de …sandoval/apuntesso/cap05.pdf1 sistemas operativos:...

1

Sistemas operativos: una visión aplicada

Capítulo 5 Comunicación y sincronización

de procesos

Sistemas operativos: una visión aplicada 1 © J. Carretero, F. García, P. de Miguel, F. Pérez

Contenido

• Procesos concurrentes. • Problemas clásicos de comunicación y sincronización. • Mecanismos de comunicación y sincronización.• Paso de mensajes.• Aspectos de implementación• Interbloqueos. • Servicios POSIX• Servicios Win32

2


Procesos concurrentes

• Modelos – Multiprogramación en un único procesador – Multiprocesador – Multicomputador (proceso distribuido)

• Razones – Compartir recursos físicos – Compartir recursos lógicos – Acelerar los cálculos – Modularidad – Comodidad


Sistema multiprogramado con un una CPU

Tiempo

Proceso A

Proceso B

Proceso C

3


Ejecución en un sistema multiprocesador

Tiempo

Proceso B

Proceso A

Proceso C

Proceso D

CPU 1

CPU 2


Tipos de procesos concurrentes

• Tipos de procesos – Independientes – Cooperantes

• Interacción entre procesos – Compiten por recursos – Comparten recursos

4


Problemas clásicos de comunicación y sincronización

• El problema de la sección crítica• El problema del productor-consumidor• El problema de los lectores-escritores• Comunicación cliente-servidor


Problema de la sección crítica

• Sistema compuesto por n procesos • Cada uno tiene un fragmento de código: sección crítica• Sólo uno de los procesos en cada instante puede ejecutar en la

sección crítica– Cuando un proceso está ejecutando en la sección crítica,

ningún otro puede hacerlo

5


Ejemplo 1

S1 = 1 +...+ 50

ni = 1nf = 50

ni =51nf = 100

S2 = 51 +....+ 100

Proceso ligeroprincipal

suma_total = S1 + S2


Ejemplo 1

• Calcula la suma de los N primeros números utilizando procesos ligeros.int suma_total = 0; void suma_parcial(int ni, int nf) {

int j = 0;int suma_parcial = 0;for (j = ni; j <= nf; j++)

suma_parcial = suma_parcial + j;suma_total = suma_total + suma_parcial;pthread_exit(0);

}

• Si varios procesos ejecutan concurrentemente este código se puede obtener un resultado incorrecto.

• Solución: secciones críticas

6


Ejemplo con sección crítica

void suma_parcial(int ni, int nf) {int j = 0;int suma_parcial = 0;for (j = ni; j <= nf; j++)

suma_parcial = suma_parcial + j;

<Entrada en la sección crítica>suma_total = suma_total + suma_parcial;<Salida de la sección crítica>pthread_exit(0);

}


Ejemplo 2void ingresar(char *cuenta, int cantidad) {

int saldo, fd;fd = open(cuenta, O_RDWR);read(fd, &saldo, sizeof(int));saldo = saldo + cantidad;lseek(fd, 0, SEEK_SET);write(fd, &saldo, sizeof(int));close(fd);return;

}

• Si dos procesos ejecutan concurrentemente este código se puede perder algún ingreso.

• Solución: secciones críticas

7


Ejemplo 2 con sección crítica

void ingresar(char *cuenta, int cantidad) {int saldo, fd;

fd = open(cuenta, O_RDWR);<Entrada en la sección crítica>

read(fd, &saldo, sizeof(int));saldo = saldo + cantidad;lseek(fd, 0, SEEK_SET);write(fd, &saldo, sizeof(int));

<Salida de la sección crítica>close(fd);return;

}


Ejemplo 3

Procesador 1 Procesador 2

PID = 500

PID = 501

PID = 501

PID = 500

Lee PID

Escribe PID

Escribe PID

Incrementa yasigna PID

Incrementa yasigna PID

PID = 500

Registro o posición de memoria

PID = 501

PID = 501

Lee PID

8


Solución al problema de la sección crítica

• Estructura general de cualquier mecanismo utilizado para resolver el problema de la sección crítica:

Entrada en la sección críticaCódigo de la sección críticaSalida de la sección crítica

• Requisitos que debe ofrecer cualquier solución para resolver el problema de la sección crítica:– Exclusión mutua – Progreso – Espera limitada


Problema del productor-consumidor

ProcesoProductor

ProcesoConsumidor

Mecanismo de comunicación

Flujo de datos

9


El problema de los lectores-escritores

EscritorLector Lector Escritor Lector

Recurso


Comunicación cliente-servidor

Computador Computador

Procesocliente

S.O.

Petición

Respuesta

Procesoservidor

10


Mecanismos de comunicación

• Archivos• Tuberías (pipes, FIFOS)• Variables en memoria compartida • Paso de mensajes


Mecanismos de Sincronización

• Construcciones de los lenguajes concurrentes (procesos ligeros) • Servicios del sistema operativo:

– Señales (asincronismo) – Tuberías (pipes, FIFOS)– Semáforos – Mutex y variables condicionales – Paso de mensajes

• Las operaciones de sincronización deben ser atómicas

11


Tuberías (POSIX)

• Mecanismo de comunicación y sincronización – Sin nombre: pipes– Con nombre: FIFOS

• Sólo puede utilizarse entre los procesos hijos del proceso que creó el pipe

int pipe(int fildes[2]);

• Identificación: dos descriptores de archivo– Para lectura– Para escritura

• Flujo de datos: unidireccional • Mecanismo con capacidad de almacenamiento


Comunicación unidireccional con tuberías

Procesode Usuario

Procesode Usuario

pipe

SO

write read

Flujo de datos

12


Comunicación bidireccional con tuberías

Procesode Usuario

Procesode Usuario

SO

write write readread

Flujo de datos

Flujo de datos

pipe

pipe


Tuberías (II)

• read(fildes[0], buffer, n)– Pipe vacío se bloquea el lector – Pipe con p bytes

• Si p ≥ n devuelve n• Si p < n devuelve p

– Si pipe vacío y no hay escritores devuelve 0

• write(fildes[1], buffer, n)– Pipe lleno se bloquea el escritor – Si no hay lectores se recibe la señal SIGPIPE

• Lecturas y escrituras atómicas (cuidado con tamaños grandes)

13


Secciones críticas con tuberías

void main(void) {int fildes[2]; /* pipe para sincronizar */char c; /* caracter para sincronizar */

pipe(fildes);write(fildes[1], &c, 1); /* necesario para entrar en la

seccion critica la primera vez */if (fork() == 0) { /* proceso hijo */

for(;;) {read(fildes[0], &c, 1); /* entrada seccion critica */< Seccion critica >write(fildes[1], &c, 1); /* salida seccion critica */

}


Secciones críticas con tuberías (II)

} else { /* proceso padre */for(;;) {

read(fildes[0], &c, 1); /* entrada seccion critica */< seccion critica >write(fildes[1], &c, 1); /* salida seccion critica */

}}

}

14


Productor-consumidor con tuberías

void main(void) {int fildes[2]; /* pipe para comunicar y sincronizar */int dato_p[4]; /* datos a producir */int dato_c; /* dato a consumir */

pipe(fildes);

if (fork() == 0) { /* proceso hijo: productor */for(;;) {

< producir dato_p, escribe 4 enteros *write(fildes[1], dato_p, 4*sizeof(int));

}


Productor-consumidor con tuberías (II)

} else { /* proceso padre: consumidor */

for(;;) { read(fildes[0], &dato, sizeof(int)); /* consumir dato, lee un entero */

}}

}

Procesohijo

Procesopadre

Pipe

15


Ejecución de mandatos con tuberías/* programa que ejecuta el mandato ``ls | wc'' */

void main(void) {

int fd[2];pid_t pid;

if (pipe(fd) < 0) {perror(``pipe'');exit(-1);

}pid = fork(); switch(pid) {

case -1: /* error */perror(``fork'');exit(-1);

ls wcpipe


Ejecución de mandatos con tuberías (II)

case 0: /* proceso hijo ejecuta ``ls'' */close(fd[0]); /* cierra el pipe de lectura */close(STDOUT_FILENO); /* cierra la salida estandar */dup(fd[1]);close(fd[1]);execlp(``ls'',``ls'',NULL);perror(``execlp'');exit(-1);

default: /* proceso padre ejecuta ``wc'' */close(fd[1]); /* cierra el pipe de escritura */close(STDIN_FILENO); /* cierra la entrada estandar */dup(fd[0]);close(fd[0]); execlp(``wc'',``wc'',NULL);perror(``execlp'');

}}

16


Ejecución de mandatos con tuberías (III)•Proceso

•STDIN•STDOUT

•pipe(fd) •fork()

•Proceso

•STDIN•STDOUT•fd[0]•fd[1]

•pipe

•redirección

•Proceso hijo


•Proceso


•pipe

•exec

•Proceso hijo

•STDIN

•STDOUT

•Proceso

•STDIN

•STDOUT•pipe

•Proceso hijo

•STDIN

•STDOUT

•Proceso

•ls •wc

•STDIN

•STDOUT•pipe


Tuberías con nombre en POSIX (FIFOS)

• Igual que los pipes • Mecanismo de comunicación y sincronización con nombre • Misma máquina • Servicios

– int mkfifo(char *name, mode_t mode);• Crea un FIFO con nombre name

– int open(char *name, int flag);• Abre un FIFO (para lectura, escritura o ambas) • Bloquea hasta que haya algún proceso en el otro extremo

• Lectura y escritura mediante read() y write()– Igual semántica que los pipes

• Cierre de un FIFO mediante close()• Borrado de un FIFO mediante unlink()

17


Semáforos

• Mecanismo de sincronización • Misma máquina • Objeto con un valor entero • Dos operaciones atómicas

– wait– signal


Operaciones sobre semáforos

wait(s){

s = s - 1;if (s < 0) {

<Bloquear al proceso>}

}

signal(s){

s = s + 1;if (s <= 0)

<Desbloquear a un proceso bloqueado por la operacion wait>

}}

18


Secciones críticas con semáforos

wait(s); /* entrada en la seccion critica */< seccion critica >signal(s); /* salida de la seccion critica */

• El semáforo debe tener valor inicial 1 P0

Valor delsemáforo (s)

wait(s)

signal(s)

signal(s)

signal(s)

wait(s)

desbloquea

desbloquea

wait(s)

1

1

0-1

-2

-1

0

P1 P2

Ejecutando código de la sección crítica

Proceso bloqueado en el semáforo


Semáforos POSIX• int sem_init(sem_t *sem, int shared, int val);

– Inicializa un semáforo sin nombre• int sem_destroy(sem_t *sem);

– Destruye un semáforo sin nombre• sem_t *sem_open(char *name, int flag, mode_t mode,

int val);– Abre (crea) un semáforo con nombre.

• int sem_close(sem_t *sem);– Cierra un semáforo con nombre.

• int sem_unlink(char *name);– Borra un semáforo con nombre.

• int sem_wait(sem_t *sem);– Realiza la operación wait sobre un semáforo.

• int sem_post(sem_t *sem);– Realiza la operación signal sobre un semáforo.

19


Productor-consumidor con semáforos (buffer acotado y circular)

Consumidor

Productor


Productor-consumidor con semáforos (II)

#define MAX_BUFFER 1024 /* tamanio del buffer */#define DATOS_A_PRODUCIR 100000 /* datos a producir */

sem_t elementos; /* elementos en el buffer */sem_t huecos; /* huecos en el buffer */int buffer[MAX_BUFFER]; /* buffer comun */

void main(void){

pthread_t th1, th2; /* identificadores de threads */

/* inicializar los semaforos */sem_init(&elementos, 0, 0);sem_init(&huecos, 0, MAX_BUFFER);

20


Productor-consumidor con semáforos (III)

/* crear los procesos ligeros */pthread_create(&th1, NULL, Productor, NULL);pthread_create(&th2, NULL, Consumidor, NULL);

/* esperar su finalizacion */pthread_join(th1, NULL);pthread_join(th2, NULL);

sem_destroy(&huecos);sem_destroy(&elementos);exit(0);

}


Productor-consumidor con semáforos (IV)void Productor(void) /* codigo del productor */{

int pos = 0; /* posicion dentro del buffer */int dato; /* dato a producir */int i;

for(i=0; i < DATOS_A_PRODUCIR; i++ ) {dato = i; /* producir dato */sem_wait(&huecos); /* un hueco menos */buffer[pos] = i;pos = (pos + 1) % MAX_BUFFER;sem_post(&elementos); /* un elemento mas */

}pthread_exit(0);

}

21


Productor-consumidor con semáforos (V)

void Consumidor(void) /* codigo del Consumidor */{

int pos = 0;int dato;int i;

for(i=0; i < DATOS_A_PRODUCIR; i++ ) {sem_wait(&elementos); /* un elemento menos */dato = buffer[pos];pos = (pos + 1) % MAX_BUFFER;sem_post(&huecos); /* un hueco mas *//* consumir dato */

}pthread_exit(0);

}


Lectores-escritores con semáforos

int dato = 5; /* recurso */int n_lectores = 0; /* numero de lectores */sem_t sem_lec; /* controlar el acceso n_lectores */sem_t mutex; /* controlar el acceso a dato */

void main(void){

pthread_t th1, th2, th3, th4;

sem_init(&mutex, 0, 1);sem_init(&sem_lec, 0, 1);

pthread_create(&th1, NULL, Lector, NULL);pthread_create(&th2, NULL, Escritor, NULL);pthread_create(&th3, NULL, Lector, NULL);pthread_create(&th4, NULL, Escritor, NULL);

22


Lectores-escritores con semáforos (II)

pthread_join(th1, NULL);pthread_join(th2, NULL);pthread_join(th3, NULL);pthread_join(th4, NULL);

/* cerrar todos los semaforos */sem_destroy(&mutex);sem_destroy(&sem_lec);

exit(0);}


Lectores-escritores con semáforos (III)

/* codigo del lector */void Lector(void) { /* codigo del lector */

sem_wait(&sem_lec);n_lectores = n_lectores + 1;if (n_lectores == 1)

sem_wait(&mutex);sem_post(&sem_lec);

printf(``%d\n'', dato); /* leer dato */

sem_wait(&sem_lec);n_lectores = n_lectores - 1;if (n_lectores == 0)

sem_post(&mutex);sem_post(&sem_lec);pthread_exit(0);

}

23


Lectores-escritores con semáforos (IV)

/* código del escritor */

void Escritor(void) { /* codigo del escritor */sem_wait(&mutex); dato = dato + 2; /* modificar el recurso */sem_post(&mutex);

pthread_exit(0);}


Memoria compartida

• Declaración independiente de variables

Datos

Texto

Proceso A Proceso B

Pila

TextoDatos

PilaSegmento de memoriacompartida

var1

2

var2

24


Mutex

• Un mutex es un mecanismo de sincronización indicado para procesos ligeros.

• Es un semáforo binario con dos operaciones atómicas: – lock(m) Intenta bloquear el mutex, si el mutex ya está

bloqueado el proceso se suspende. – unlock(m) Desbloquea el mutex, si existen procesos

bloqueados en el mutex se desbloquea a uno.


Secciones críticas con mutex

lock(m); /* entrada en la seccion critica */< seccion critica >unlock(s); /* salida de la seccion critica */

• La operación unlock debe realizarla el proceso ligero que ejecutó lock

Proceso ligero A

lock mutex

Seccióncrítica

Proceso ligero B

lock mutex

unlock mutex obtiene mutex Proceso ligero ejecutando

Proceso ligero bloqueado

Punto de sincronización

25


Paso de mensajes• Permite resolver:

– Exclusión mutua – Sincronizar entre un proceso que recibe un mensaje y otro que lo envía – Comunicación de datos entre espacios de memoria diferentes (mismo

computador, diferentes computadores) • Primitivas básicas:

– send(destino, mensaje) envía un mensaje al proceso destino – receive(destino, mensaje) recibe un mensaje del proceso destino

• Múltiples soluciones • Aspectos de diseño

– Tamaño del mensaje– Flujo de datos (unidireccional, bidireccional)– Nombrado

• Directo• Indirecto (puertos, colas)

– Sincronización (síncrono, asíncrono)– Almacenamiento


Uso de colas y puertos

Comunicación con puertosComunicación con colas de mensajes

Proceso cliente Proceso clientesend

mensaje

receive

Cola de mensajes

Proceso cliente Proceso cliente

mensaje

Puertosend

26


Colas de mensajes POSIX

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

– Crea una cola de mensajes con nombre y atributos attr: • Número máximo de mensajes. • Tamaño máximo del mensaje. • Bloqueante, No bloqueante.

int mq_close (mqd_t mqdes);– Cierra una cola de mensajes.

int mq_unlink(char *name);– Borra una cola de mensajes.


Colas de mensajes POSIX (II)

int mq_send(mqd_t mqdes, char *msg, size_t len, int prio);

– Envía el mensaje msg de longitud len a la cola de mensajes mqdes con prioridad prio;

– Si la cola está llena el envío puede ser bloqueante o no.

int mq_receive(mqd_t mqdes, char *msg, size_t len,int prio);

– Recibe un mensaje msg de longitud len de la cola de mensajes mqdes con prioridad prio;

– Recepción bloqueante o no.

27


Servidor multithread con colas de mensajes

Proceso cliente

Cola del cliente

Proceso cliente

Cola del cliente

Cola del servidor

Proceso servidor

petición

petición

respuestarespuesta

Creación delthread

Creación delthread

Thread quesirve la petición

Thread quesirve la petición


Servidor multithread con colas de mensajes (II)

/* estructura de un mensaje */struct mensaje {

char buffer[1024]; /* datos a enviar */char cliente[256]; /* cola del cliente */

};

/* mutex y variables condicionales para proteger la copia del mensaje */

pthread_mutex_t mutex_mensaje;int mensaje_no_copiado = TRUE;pthread_cond_t cond;

void main(void){mqd_t q_servidor; /* cola del servidor */struct mensaje mess; /* mensaje a recibir */struct mq_attr q_attr; /* atributos de la cola */pthread_attr_t t_attr; /* atributos de los threads */

28


Servidor multithread con colas de mensajes (II)

attr.mq_maxmsg = 20;attr.mq_msgsize = sizeof(struct mensaje));

q_servidor = mq_open("SERVIDOR", O_CREAT|O_RDONLY, 0700, &attr);

pthread_mutex_init(&mutex_mensaje, NULL);pthread_cond_init(&cond, NULL);pthread_attr_init(&attr);pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM);pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);


Servidor multithread con colas de mensajes (III)

while (TRUE) {mq_receive(q_servidor, &mess, sizeof(struct mensaje), 0);

pthread_create(&thid, &attr, tratar_mensaje, &mess);

/* se espera a que el thread copie el mensaje */pthread_mutex_lock(&mutex_mensaje);while (mensaje_no_copiado)

pthread_cond_wait(&cond, &mutex_mensaje);mensaje_no_copiado = TRUE;pthread_mutex_unlock(&mutex_mensaje);

}}

29


Servidor multithread con colas de mensajes (IV)

void tratar_mensaje(struct mensaje *mes){

struct mensaje mensaje_local;struct mqd_t q_cliente; /* cola del cliente */struct mensaje respueta; /* mensaje de respuesta al cliente */

/* el thread copia el mensaje */pthread_mutex_lock(&mutex_mensaje);memcpy((char *) &mensaje_local, (char *)&mes,

sizeof(struct mensaje));

/* ya se puede despertar al servidor*/pthread_mutex_lock(&mutex_mensaje);mensaje_no_copiado = FALSE;pthread_cond_signal(&cond);pthread_mutex_unlock(&mutex_mensaje);


Servidor multithread con colas de mensajes (V)

/* ejecutar la petición del cliente *//* y preparar respuesta */

/* responder al cliente a su cola */q_cliente = mq_open(mensaje_local.nombre, O_WRONLY);

mqsend(q_cliente, (char *) &respueta, sizeof(respuesta), 0);

mq_clise(q_cliente);

pthread_exit(0);}

30


Ejemplo de código cliente

/* estructura de un mensaje */struct mensaje {

char buffer[1024]; /* datos a enviar */char cliente[256]; /* cola del cliente */

};

void main(void){

mqd_t q_servidor; /* cola del servidor */mqd_t q_cliente; /* cola del cliente */struct mq_attr q_attr; /* atributos de la cola */struct mensaje peticion; /* peticion al servidor */struct mensaje respuesta; /* respuesta del servidor */

attr.mq_maxmsg = 1;attr.mq_msgsize = sizeof(struct mensaje));


Ejemplo de código cliente (II)

q_cliente = mq_open("CLIENTE", O_CREAT|O_RDONLY, 0700, 0);q_servidor = mq_open("SERVIDOR", O_WRONLY);

/* preparar peticion */mq_send(q_servidor, &petcicion, sizeof(struct mensaje), 0);

/* esperar respuesta */mq_receive(q_cliente, &respuesta, sizeof(struct mensaje), 0);

mq_close(q_servidor);mq_close(q_cliente);mq_unlink("CLIENTE");

exit(0);}

31


Implementación de mecanismos de sincronización

• Espera activa:wait(s) {

s = s – 1;while (s < 0)

;

signal(s) {s = s + 1;

• Espera pasivawait(s) {

s = s – 1;if (s < 0)

Bloquear al proceso;

signal(s) {s = s + 1;if (s <= 0)

Desbloquear a un proceso bloqueado en la operación wait;}


Implementación de la espera pasiva

• Operaciones para bloquear a un proceso en un semáforo

(a)

Tabla de procesos

BCP1 BCP7BCP2 BCP8BCP3 BCP9BCP4 BCP10BCP5 BCP11BCP6 BCP12

1 90 56 11 87 0

Cola asociada al semáforo 7

(b)

Tabla de procesos


1 90 56 11 87Bloq.

Bloq. Ejec.EstadoPID

EstadoPID

Bloq. Bloq.0

Cola asociada al semáforo 7 11

32


Implementación de la espera pasiva

• Operaciones para desbloquear a un proceso bloqueado en un semáforo

(a)

(b)

Tabla de procesos


1 90 56 11 87ListoEstado

PIDBloq. Bloq.

0

Cola asociada al semáforo 11

Tabla de procesos


1 90 56 11 87Bloq.Estado

PIDBloq. Bloq.

0

Cola asociada al semáforo 7 11


Instrucciones hardware especiales

• Operación atómicasint test-and-set(int *valor) {int temp;

temp = *valor;*valor = 1; /* true */return temp;

}

void swap (int *a, int *b) {int temp;

temp = *a;*a = *b;*b = temp;return;

}

33


Sección crítica con test-and-set

• Los procesos comparten la variable lock (con valor inicial afalse)

while (test-and-set(&lock));

<Código de la sección crítica>

lock = false;


Sección crítica con swap

• Los procesos comparten la variable lock con valor inicial false.• Cada proceso utiliza una variable local llave.

llave = true;do

swap(lock, llave);while (llave != false);<Código de la sección crítica>lock = false;

34


Implementación de un semáforo con test-and-set

wait(s){while (test-and-set(&valor_s))

;s = s - 1;if (s < 0){

valor_s = false;Bloquear al proceso;

}else

valor_s = false;}

signal(s){while (test-and-set(&valor_s))

;s = s + 1;if ( s <= 0){

Desbloquear a un proceso bloqueado en la operación wait;

}valor_s = false;

}


Interbloqueos

• Bloqueo permanente de un conjunto de procesos que compiten por los recursos del sistema o se comunican entre sí.

• Ejemplo: Si P y Q con semáforos con valor inicial 1

P1 P2wait(P) wait(Q)wait(Q) wait(P)... ...

signal(P) signal(Q)signal(Q) siangl(P)

35


Ejemplo de interbloqueo

Q

P

BA


Interbloqueos II

• Ejemplo: Si C1 y C2 son dos colas de mensajes:

P1 P2receive(P2, M) receive(P1, N)... ...

send(P2, M) send(P1, N)

• Condiciones del interbloqueo: – Exclusión mutua – Retención y espera – No apropiación – Espera circular

36


Servicios Posix: Tuberías

• Crear una tubería sin nombre– int pipe(int fildes[2]);

• Crear una tuberías con nombre– int mkfifo(char *name, mode_t mode);

• Abrir una tubería con nombre– int open(char *fifo, int flag);

• Cerrar una tubería– int close(int fd);

• Borrar una tubería con nombre– int unlink(char *fifo);

• Leer de una tubería– int read(fildes[0], buffer, n);

• Escribir en una tubería– int write(fildes[1], buffer, n);


Servicios Posix: Semáforos

• int sem_init(sem_t *sem, int shared, int val);– Inicializa un semáforo sin nombre

• int sem_destroy(sem_t *sem);– Destruye un semáforo sin nombre

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

– Abre (crea) un semáforo con nombre.• int sem_close(sem_t *sem);

– Cierra un semáforo con nombre.• int sem_unlink(char *name);

– Borra un semáforo con nombre.• int sem_wait(sem_t *sem);

– Realiza la operación wait sobre un semáforo. • int sem_post(sem_t *sem);

– Realiza la operación signal sobre un semáforo.

37


Servicios Posix: Mutex

• int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t * attr);

– Inicializa un mutex.

• int pthread_mutex_destroy(pthread_mutex_t *mutex) ;– Destruye un mutex.

• int pthread_mutex_lock(pthread_mutex_t *mutex);– Intenta obtener el mutex. Bloquea al proceso ligero si el mutex se

encuentra adquirido por otro proceso ligero. • int pthread_mutex_unlock(pthread_mutex_t *mutex);

– Desbloquea el mutex.


Servicios Posix: Colas de mensajes

• mqd_t mq_open(char *name, int flag, mode_t mode, mq_attr *attr);

– Crea una cola de mensajes con nombre y atributos attr: • Número máximo de mensajes. • Tamaño máximo del mensaje. • Bloqueante, No bloqueante.

• int mq_close (mqd_t mqdes);– Cierra una cola de mensajes.

• int mq_unlink(char *name);– Borra una cola de mensajes.

38


Servicios Posix: Colas de mensajes (II)

• int mq_send(mqd_t mqdes, char *msg, size_t len, int prio);

– Envía el mensaje msg de longitud len a la cola de mensajes mqdes con prioridad prio;

– Si la cola está llena el envío puede ser bloqueante o no.

• int mq_receive(mqd_t mqdes, char *msg, size_t len,int prio);

– Recibe un mensaje msg de longitud len de la cola de mensajes mqdes con prioridad prio;

– Recepción bloqueante o no.


Wind32: Servicios de sincronización

• DWORD WaitForSingleObject(HANDLE hHandle, DWORDdwMilliseconds);

• DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles, BOOL fWaitFail, DWORD dwMilliseconds);

39


Wind32: Tuberías

• Crear una tubería sin nombre– BOOL CreatePipe(PHANDLE phRead, PHANDLE phWrite,

LPSECURITY_ATTRIBUTES lpsa, DWORD cbPipe);

• Crear una tubería con nombre– HANDLE CreateNamedPipe (LPCTSTR lpszPipeName, DWORD

fdwOpenMode, DWORD fdwPipeMode, DWORD nMaxInstances, DWORD cbOutBuf, DWORD cbInBuf, DWORD dwTimeOut, LPSECURITY_ATTRIBUTES lpsa);

• Abrir una tubería con nombre – HANDLE CreateFile(LPCSTR lpFileName, DWORD

dwDesiredAccess,DWORD dwShareMode, LPVOIDlpSecurityAttributes, DWORD CreationDisposition, DWORDdwFlagsAndAttributes, HANDLE hTemplateFile);


Wind32: Tuberías (II)

• Cerrar una tubería con nombre– BOOL CloseHandle (HANDLE hfile);

• Leer de una tubería– BOOL ReadFile (HANDLE hFile, LPVOID lpBuffer, DWORD

nBytes, LPDWORD lpnBytes, LPOVERLAPPED lpOverlapped);

• Escribir en una tubería– BOOL WriteFile (HANDLE hFile, LPVOID lpBuffer, DWORD

nBytes, LPDWORD lpnBytes, LPOVERLAPPED lpOverlapped);

40


Wind32: Secciones críticas

• VOID InitializeCriticalSection(LPCCRITICAL_SECTION lpcsCriticalSection);

• VOID DeleteCriticalSection(LPCCRITICAL_SECTION lpcsCriticalSection);

• VOID EnterCriticalSection(LPCCRITICAL_SECTION lpcsCriticalSection);

• VOID LeaveCriticalSection(LPCCRITICAL_SECTION lpcsCriticalSection);


Wind32: Semáforos

• Crear un semáforo– HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpsa,

LONG cSemInitial, LONG cSemMax, LPCTSTRlpszSemName);

• Abrir un semáforo– HANDLE OpenSemaphore(LONG dwDesiredAccess, LONG

BinheritHandle, lpszName SemName);

• Operación wait– DWORD WaitForSingleObject(HANDLE hSem,

DWORD dwTimeOut);

• Operación signal– BOOL ReleaseSemaphore(HANDLE hSemaphore,

LONG cReleaseCount, LPLONG lpPreviousCount);

41


Wind32: Mutex y eventos

• Crear un mutex– HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpsa, BOOL fInitialOwner, LPCTSTR lpszMutexName);

• Abrir un mutex– HANDLE OpenMutex(LONG dwDesiredAccess, LONG BineheritHandle,

lpszName SemName);

• Cerrar un mutex– BOOL CloseHandle(HANDLE hObject);

• Operación lock– DWORD WaitForSingleObject(HANDLE hMutex, DWORD dwTimeOut);

• Operación unlonk– BOOL ReleaseMutex(HANDLE hMutex);


Wind32: Mutex y eventos (II)

• Crear un evento– HANDLE CreateEvent(LPSECURITY_ATTRIBUTES lpsa, BOOL

fManualReset, BOOL fInitialState, LPTCSTR lpszEventName);

• Destruir un evento– BOOL CloseHandle(HANDLE hObject);

• Esperar por un evento– DWORD WaitForSingleObject(HANDLE hEvent, DWORD

dwTimeOut);

• Notificar un evento– BOOL SetEvent(HANDLE hEvent);– BOOL PulseEvent(HANDLE hEvent);

capítulo 5 comunicación y sincronización de …sandoval/apuntesso/cap05.pdf1 sistemas operativos:...

Documents