Sistemas operativos: una visión aplicada. Capítulo 5 Comunicación y sincronización de procesos
|
|
- Daniel Río Robles
- hace 5 años
- Vistas:
Transcripción
1 Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos
2 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 Sistemas operativos: una visión aplicada 2 J. Carretero, F. García, P. de Miguel, F. Pérez
3 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 Sistemas operativos: una visión aplicada 3 J. Carretero, F. García, P. de Miguel, F. Pérez
4 Sistema multiprogramado con un una CPU P r o c e s o A P r o c e s o B P r o c e s o C T i e m p o Sistemas operativos: una visión aplicada 4 J. Carretero, F. García, P. de Miguel, F. Pérez
5 Ejecución en un sistema multiprocesador P P P r o c e s o A r o c e s o B r o c e s o C C P U 1 C P U 2 P r o c e s o D T i e m p o Sistemas operativos: una visión aplicada 5 J. Carretero, F. García, P. de Miguel, F. Pérez
6 Tipos de procesos concurrentes Tipos de procesos Independientes Cooperantes Interacción entre procesos Compiten por recursos Comparten recursos Sistemas operativos: una visión aplicada 6 J. Carretero, F. García, P. de Miguel, F. Pérez
7 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 Sistemas operativos: una visión aplicada 7 J. Carretero, F. García, P. de Miguel, F. Pérez
8 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 Sistemas operativos: una visión aplicada 8 J. Carretero, F. García, P. de Miguel, F. Pérez
9 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 Sistemas operativos: una visión aplicada 9 J. Carretero, F. García, P. de Miguel, F. Pérez
10 Ejemplo 1 P r o c e s o l i g e r o p r i n c i p a l n i = 1 n f = 5 0 S 1 = S 2 = n i = 5 1 n f = s u m a _ t o t a l = S 1 + S 2 Sistemas operativos: una visión aplicada 10 J. Carretero, F. García, P. de Miguel, F. Pérez
11 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 Sistemas operativos: una visión aplicada 11 J. Carretero, F. García, P. de Miguel, F. Pérez
12 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); Sistemas operativos: una visión aplicada 12 J. Carretero, F. García, P. de Miguel, F. Pérez
13 Ejemplo 2 void 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 Sistemas operativos: una visión aplicada 13 J. Carretero, F. García, P. de Miguel, F. Pérez
14 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; Sistemas operativos: una visión aplicada 14 J. Carretero, F. García, P. de Miguel, F. Pérez
15 Ejemplo 3 P r o c e s a d o r 1 P r o c e s a d o r 2 L e e P I D P I D = R e g i s t r o o p o s i c i ó n d e m e m o r i a P I D = I n c r e m e n t a y a s i g n a P I D L e e P I D P I D = P I D = E s c r i b e P I D P I D = I n c r e m e n t a y a s i g n a P I D P I D = P I D = E s c r i b e P I D Sistemas operativos: una visión aplicada 15 J. Carretero, F. García, P. de Miguel, F. Pérez
16 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ítica Código de la sección crítica Salida 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 Sistemas operativos: una visión aplicada 16 J. Carretero, F. García, P. de Miguel, F. Pérez
17 Problema del productor-consumidor P r o c e s o P r o d u c t o r P r o c e s o C o n s u m i d o r F l u j o d e d a t o s M e c a n i s m o d e c o m u n i c a c i ó n Sistemas operativos: una visión aplicada 17 J. Carretero, F. García, P. de Miguel, F. Pérez
18 El problema de los lectores-escritores L e c t o r L e c t o r E s c r i t o r L e c t o r E s c r i t o r R e c u r s o Sistemas operativos: una visión aplicada 18 J. Carretero, F. García, P. de Miguel, F. Pérez
19 Comunicación cliente-servidor C o m p u t a d o r C o m p u t a d o r P e t i c i ó n P r o c e s o c l i e n t e P r o c e s o s e r v i d o r S. O. R e s p u e s t a Sistemas operativos: una visión aplicada 19 J. Carretero, F. García, P. de Miguel, F. Pérez
20 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 Sistemas operativos: una visión aplicada 20 J. Carretero, F. García, P. de Miguel, F. Pérez
21 Mecanismos de comunicación Archivos Tuberías (pipes, FIFOS) Variables en memoria compartida Paso de mensajes Sistemas operativos: una visión aplicada 21 J. Carretero, F. García, P. de Miguel, F. Pérez
22 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 Sistemas operativos: una visión aplicada 22 J. Carretero, F. García, P. de Miguel, F. Pérez
23 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 Sistemas operativos: una visión aplicada 23 J. Carretero, F. García, P. de Miguel, F. Pérez
24 Comunicación unidireccional con tuberías w r i t e P r o c e s o P r o c e s o r e a d d e U s u a r i o d e U s u a r i o S O p i p e F l u j o d e d a t o s Sistemas operativos: una visión aplicada 24 J. Carretero, F. García, P. de Miguel, F. Pérez
25 Comunicación bidireccional con tuberías w r i t e P r o c e s o r e a d w r i t e P r o c e s o r e a d d e U s u a r i o d e U s u a r i o S O p i p e F l u j o d e d a t o s p i p e F l u j o d e d a t o s Sistemas operativos: una visión aplicada 25 J. Carretero, F. García, P. de Miguel, F. Pérez
26 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) Sistemas operativos: una visión aplicada 26 J. Carretero, F. García, P. de Miguel, F. Pérez
27 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 */ Sistemas operativos: una visión aplicada 27 J. Carretero, F. García, P. de Miguel, F. Pérez
28 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 */ Sistemas operativos: una visión aplicada 28 J. Carretero, F. García, P. de Miguel, F. Pérez
29 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)); Sistemas operativos: una visión aplicada 29 J. Carretero, F. García, P. de Miguel, F. Pérez
30 Productor-consumidor con tuberías (II) else { /* proceso padre: consumidor */ for(;;) { read(fildes[0], &dato, sizeof(int)); /* consumir dato, lee un entero */ Proceso hijo Pipe Proceso padre Sistemas operativos: una visión aplicada 30 J. Carretero, F. García, P. de Miguel, F. Pérez
31 Ejecución de mandatos con tuberías /* programa que ejecuta el mandato ``ls wc'' */ void main(void) { int fd[2]; pid_t pid; ls pipe wc if (pipe(fd) < 0) { perror(``pipe''); exit(-1); pid = fork(); switch(pid) { case -1: /* error */ perror(``fork''); exit(-1); Sistemas operativos: una visión aplicada 31 J. Carretero, F. García, P. de Miguel, F. Pérez
32 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''); Sistemas operativos: una visión aplicada 32 J. Carretero, F. García, P. de Miguel, F. Pérez
33 Ejecución de mandatos con tuberías (III) Proceso Proceso STDIN STDOUT pipe(fd) STDIN STDOUT fd[0] fd[1] pipe fork() Proceso Proceso hijo STDIN STDOUT fd[0] fd[1] pipe STDIN STDOUT fd[0] fd[1] redirección Proceso Proceso hijo STDIN STDOUT pipe STDIN STDOUT exec Proceso Proceso hijo STDIN STDOUT pipe STDIN STDOUT ls wc Sistemas operativos: una visión aplicada 33 J. Carretero, F. García, P. de Miguel, F. Pérez
34 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() Sistemas operativos: una visión aplicada 34 J. Carretero, F. García, P. de Miguel, F. Pérez
35 Semáforos Mecanismo de sincronización Misma máquina Objeto con un valor entero Dos operaciones atómicas wait signal Sistemas operativos: una visión aplicada 35 J. Carretero, F. García, P. de Miguel, F. Pérez
36 Operaciones sobre emá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> Sistemas operativos: una visión aplicada 36 J. Carretero, F. García, P. de Miguel, F. Pérez
37 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 Valor del semáforo (s) P 0 P 1 P wait(s) wait(s) wait(s) -1 signal(s) desbloquea 0 signal(s) desbloquea Ejecutando código de la sección crítica 1 signal(s) Proceso bloqueado en el semáforo Sistemas operativos: una visión aplicada 37 J. Carretero, F. García, P. de Miguel, F. Pérez
38 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. Sistemas operativos: una visión aplicada 38 J. Carretero, F. García, P. de Miguel, F. Pérez
39 Productor-consumidor con semáforos (buffer acotado y circular) Productor Consumidor Sistemas operativos: una visión aplicada 39 J. Carretero, F. García, P. de Miguel, F. Pérez
40 Productor-consumidor con semáforos (II) #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* 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); Sistemas operativos: una visión aplicada 40 J. Carretero, F. García, P. de Miguel, F. Pérez
41 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); Sistemas operativos: una visión aplicada 41 J. Carretero, F. García, P. de Miguel, F. Pérez
42 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); Sistemas operativos: una visión aplicada 42 J. Carretero, F. García, P. de Miguel, F. Pérez
43 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 */ /* cosumir dato */ pthread_exit(0); Sistemas operativos: una visión aplicada 43 J. Carretero, F. García, P. de Miguel, F. Pérez
44 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); Sistemas operativos: una visión aplicada 44 J. Carretero, F. García, P. de Miguel, F. Pérez
45 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); Sistemas operativos: una visión aplicada 45 J. Carretero, F. García, P. de Miguel, F. Pérez
46 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); Sistemas operativos: una visión aplicada 46 J. Carretero, F. García, P. de Miguel, F. Pérez
47 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); Sistemas operativos: una visión aplicada 47 J. Carretero, F. García, P. de Miguel, F. Pérez
48 Memoria compartida P r o c e s o A P r o c e s o B T e x t o D a t o s T e x t o D a t o s v a r 2 v a r 1 P i l a 2 S e g m e n t o d e m e m o r i a c o m p a r t i d a P i l a Declaración independiente de variables Sistemas operativos: una visión aplicada 48 J. Carretero, F. García, P. de Miguel, F. Pérez
49 Productor-consumidor con memoria compartida Productor: Crea los semáforos (shm_open) Crea la zona de memoria compartida utilizando un archivo proyectado en memoria (open) Le asigna espacio (ftruncate) Proyecta el archivo en su espacio de direcciones (mmap) Utiliza la zona de memoria compartida Desproyecta la zona de memoria compartida Cierra y borra el archivo. Consumidor: Abre los semáforos (shm_open) Debe esperar a que archivo esté creado para abrirlo (open) Proyecta el archivo en su espacio de direcciones (mmap) Utiliza la zona de memoria compartida Cierra el archivo. Sistemas operativos: una visión aplicada 49 J. Carretero, F. García, P. de Miguel, F. Pérez
50 Código del productor #define MAX_BUFFER 1024 /* tamaño del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ sem_t *elementos; /* elementos en el buffer */ sem_t *huecos; /* huecos en el buffer */ void main(int argc, char *argv[]){ int shd; int *buffer; /* buffer comun */ /* el productor crea el archivo a proyectar */ shd = open("buffer", O_CREAT O_WRONLY, 0700); ftruncate(shd, MAX_BUFFER * sizeof(int)); /*proyectar el objeto de memoria compartida en el espacio de direcciones del productor*/ buffer = (int *) mmap(null, MAX_BUFFER * sizeof(int), PROT_WRITE, MAP_SHARED, shd, 0); Sistemas operativos: una visión aplicada 50 J. Carretero, F. García, P. de Miguel, F. Pérez
51 Código del productor (II) /* El productor crea los semaforos */ elementos = sem_open("elementos", O_CREAT, 0700, 0); huecos = sem_open("huecos", O_CREAT, 0700, MAX_BUFFER); Productor(buffer); /* desproyectar el buffer compartido */ munmap(buffer, MAX_BUFFER * sizeof(int)); close(shd); /* cerrar el objeto de memoria compartida */ unlink("buffer"); /* borrar el objeto de memoria */ sem_close(elementos); sem_close(huecos); sem_unlink("elementos"); sem_unlink("huecos"); Sistemas operativos: una visión aplicada 51 J. Carretero, F. García, P. de Miguel, F. Pérez
52 Código del productor (III) void Productor(int *buffer) /* 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 */ return; Sistemas operativos: una visión aplicada 52 J. Carretero, F. García, P. de Miguel, F. Pérez
53 Código del consumidor #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ sem_t *elementos; /* elementos en el buffer */ sem_t *huecos; /* huecos en el buffer */ void main(int argc, char *argv[]){ int shd; int *buffer; /* buffer comun */ /* el consumidor abre el archivo a proyectar */ shd = open("buffer", O_RDONLY); /*proyectar el objeto de memoria compartida en el espacio de direcciones del productor*/ buffer = (int *) mmap(null, MAX_BUFFER * sizeof(int), PROT_READ, MAP_SHARED, shd, 0); Sistemas operativos: una visión aplicada 53 J. Carretero, F. García, P. de Miguel, F. Pérez
54 Código del consumidor (II) /* El consumidor abre los semaforos */ elementos = sem_open("elementos", 0); huecos = sem_open("huecos", 0); Consumidor(buffer); /* desproyectar el buffer compartido */ munmap(buffer, MAX_BUFFER * sizeof(int)); close(shd); /* cerrar el objeto de memoria compartida */ /* cerrar los semaforos */ sem_close(elementos); sem_close(huecos); Sistemas operativos: una visión aplicada 54 J. Carretero, F. García, P. de Miguel, F. Pérez
55 Código del consumidor (III) void Consumidor(char *buffer) /* codigo del Consumidor */ { int pos = 0; int i, dato; 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 */ printf("consume %d \n", dato); /* cosumir dato */ return; Sistemas operativos: una visión aplicada 55 J. Carretero, F. García, P. de Miguel, F. Pérez
56 Mutex y variables condicionales 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. Sistemas operativos: una visión aplicada 56 J. Carretero, F. García, P. de Miguel, F. Pérez
57 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 P r o c e s o l i g e r o A P r o c e s o l i g e r o B l o c k m u t e x l o c k m u t e x S e c c i ó n c r í t i c a u n l o c k m u t e x o b t i e n e m u t e x P r o c e s o l i g e r o e j e c u t a n d o P r o c e s o li g e r o b l o q u e a d o P u n t o d e s i n c r o n i z a c i ó n Sistemas operativos: una visión aplicada 57 J. Carretero, F. García, P. de Miguel, F. Pérez
58 Variables condicionales Variables de sincronización asociadas a un mutex Conveniente ejecutarlas entre lock y unlock Dos operaciones atómicas: wait Bloquea al proceso ligero que la ejecuta y le expulsa del mutex signal Desbloquea a uno o varios procesos suspendidos en la variable condicional. El proceso que se despierta compite de nuevo por el mutex Sistemas operativos: una visión aplicada 58 J. Carretero, F. García, P. de Miguel, F. Pérez
59 Variables condicionales (II) P r o c e s o l i g e r o A P r o c e s o l i g e r o B l o c k l o c k w a i t u n l o c k m u t e x A d q u i e r e e l m u t e x S e c o m p i t e p o r e l m u t e x A d q u i e r e e l m u t e x s i g n a l u n l o c k P r o c e s o l i g e r o b l o q u e a d o e s p e r a n d o u n l o c k P r o c e s o l i g e r o b l o q u e a d o e s p e r a n d o s i g n a l Sistemas operativos: una visión aplicada 59 J. Carretero, F. García, P. de Miguel, F. Pérez
60 Uso de mutex y variables condicionales Proceso ligero A lock(mutex); /* acceso al recurso */ comprobar las estructuras de datos; while (recurso ocupado) wait(condition, mutex); marcar el recurso como ocupado; unlock(mutex); Proceso ligero B lock(mutex); /* acceso al recurso */ marcar el recurso como libre; signal(condition, mutex); unlock(mutex); Importante utilizar while Sistemas operativos: una visión aplicada 60 J. Carretero, F. García, P. de Miguel, F. Pérez
61 Servicios POSIX 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. int pthread_cond_init(pthread_cond_t*cond, pthread_condattr_t*attr); Inicializa una variable condicional. Sistemas operativos: una visión aplicada 61 J. Carretero, F. García, P. de Miguel, F. Pérez
62 Servicios POSIX (II) int pthread_cond_destroy(pthread_cond_t *cond); Destruye un variable condicional. int pthread_cond_signal(pthread_cond_t *cond); Se reactivan uno o más de los procesos ligeros que están suspendidos en la variable condicional cond. No tiene efecto si no hay ningún proceso ligero esperando (diferente a los semáforos). int pthread_cond_broadcast(pthread_cond_t *cond); Todos los threads suspendidos en la variable condicional cond se reactivan. No tiene efecto si no hay ningún proceso ligero esperando. int pthread_cond_wait(pthread_cond_t*cond, pthread_mutex_t*mutex); Suspende al proceso ligero hasta que otro proceso señaliza la variable condicional cond. Automáticamente se libera el mutex. Cuando se despierta el proceso ligero vuelve a competir por el mutex. Sistemas operativos: una visión aplicada 62 J. Carretero, F. García, P. de Miguel, F. Pérez
63 Productor-consumidor con mutex #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ pthread_mutex_t mutex; /* mutex para controlar el acceso al buffer compartido */ pthread_cond_t no_lleno; /* controla el llenado del buffer */ pthread_cond_t no_vacio; /* controla el vaciado del buffer */ int n_elementos; /* numero de elementos en el buffer */ int buffer[max_buffer]; /* buffer comun */ main(int argc, char *argv[]){ pthread_t th1, th2; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&no_lleno, NULL); pthread_cond_init(&no_vacio, NULL); Sistemas operativos: una visión aplicada 63 J. Carretero, F. García, P. de Miguel, F. Pérez
64 Productor-consumidor con mutex (II) pthread_create(&th1, NULL, Productor, NULL); pthread_create(&th2, NULL, Consumidor, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&no_lleno); pthread_cond_destroy(&no_vacio); exit(0); Sistemas operativos: una visión aplicada 64 J. Carretero, F. García, P. de Miguel, F. Pérez
65 Productor-consumidor con mutex (III) void Productor(void) { /* codigo del productor */ int dato, i,pos = 0; for(i=0; i < DATOS_A_PRODUCIR; i++ ) { dato = i; /* producir dato */ pthread_mutex_lock(&mutex); /* acceder al buffer */ while (n_elementos == MAX_BUFFER) /* si buffer lleno */ pthread_cond_wait(&no_lleno, &mutex); /* se bloquea */ buffer[pos] = i; pos = (pos + 1) % MAX_BUFFER; n_elementos ++; pthread_cond_signal(&no_vacio); /* buffer no vacio */ pthread_mutex_unlock(&mutex); pthread_exit(0); Sistemas operativos: una visión aplicada 65 J. Carretero, F. García, P. de Miguel, F. Pérez
66 Productor-consumidor con mutex (IV) void Consumidor(void) { /* codigo del sonsumidor */ int dato, i,pos = 0; for(i=0; i < DATOS_A_PRODUCIR; i++ ) { pthread_mutex_lock(&mutex); /* acceder al buffer */ while (n_elementos == 0) /* si buffer vacio */ pthread_cond_wait(&no_vacio, &mutex); /* se bloquea */ dato = buffer[pos]; pos = (pos + 1) % MAX_BUFFER; n_elementos --; pthread_cond_signal(&no_lleno); /* buffer no lleno */ pthread_mutex_unlock(&mutex); printf("consume %d \n", dato); /* consume dato */ pthread_exit(0); Sistemas operativos: una visión aplicada 66 J. Carretero, F. García, P. de Miguel, F. Pérez
67 Lectores-escritores con mutex int dato = 5; /* recurso */ int n_lectores = 0; /* numero de lectores */ pthread_mutex_t mutex; /* controlar el acceso a dato */ pthread_mutex_t mutex_lectores; /* controla la variable n_lectores */ main(int argc, char *argv[]) { pthread_t th1, th2, th3, th4; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&no_lectores, NULL); pthread_create(&th1, NULL, Lector, NULL); pthread_create(&th2, NULL, Escritor, NULL); pthread_create(&th3, NULL, Lector, NULL); pthread_create(&th4, NULL, Escritor, NULL); Sistemas operativos: una visión aplicada 67 J. Carretero, F. García, P. de Miguel, F. Pérez
68 Lectores-escritores con mutex (II) pthread_join(th1, NULL); pthread_join(th2, NULL); pthread_join(th3, NULL); pthread_join(th4, NULL); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&no_lectores); exit(0); void Escritor(void) { /* codigo del escritor */ pthread_mutex_lock(&mutex); dato = dato + 2; /* modificar el recurso */ pthread_mutex_unlock(&mutex); pthread_exit(0); Sistemas operativos: una visión aplicada 68 J. Carretero, F. García, P. de Miguel, F. Pérez
69 Lectores-escritores con mutex (III) void Lector(void) { /* codigo del lector */ pthread_mutex_lock(&mutex_lectores); n_lectores++; if (n_lectores == 1) pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex_lectores); printf("%d\n", dato); /* leer dato */ pthread_mutex_lock(&mutex_lectores); n_lectores--; if (n_lectores == 0) pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex_lectores); pthread_exit(0); Sistemas operativos: una visión aplicada 69 J. Carretero, F. García, P. de Miguel, F. Pérez
70 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 Sistemas operativos: una visión aplicada 70 J. Carretero, F. García, P. de Miguel, F. Pérez
71 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 Sistemas operativos: una visión aplicada 71 J. Carretero, F. García, P. de Miguel, F. Pérez
72 Uso de colas y puertos P r o c e s o c l i e n t e P r o c e s o c l i e n t e s e n d r e c e i v e P r o c e s o c l i e n t e P r o c e s o c l i e n t e s e n d P u e r t o m e n s a j e m e n s a j e C o l a d e m e n s a j e s C o m u n i c a c i ó n c o n c o l a s d e m e n s a j e s C o m u n i c a c i ó n c o n p u e r t o s Sistemas operativos: una visión aplicada 72 J. Carretero, F. García, P. de Miguel, F. Pérez
73 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. Sistemas operativos: una visión aplicada 73 J. Carretero, F. García, P. de Miguel, F. Pérez
74 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. Sistemas operativos: una visión aplicada 74 J. Carretero, F. García, P. de Miguel, F. Pérez
75 Secciones críticas con colas de mensajes void main(void) { mqd_t mutex; /* cola de mensajes para sincronizar el acceso a la seccion critica */ struct mq_attr attr; /* atributos de la cola de mensajes */ char c; /* caracter para sincronizar */ attr.mq_maxmsg = 1; /* numero maximo de mensajes */ attr.mq_msgsize = 1; /* tamanio del mensaje */ mutex = mq_open(``mutex'', O_CREAT O_RDWR, 0777, &attr); mq_send(mutex, &c, 1, 0); seccion /* necesario para entrar en la critica la primera vez */ Sistemas operativos: una visión aplicada 75 J. Carretero, F. García, P. de Miguel, F. Pérez
76 Secciones críticas con colas de mensajes (II) if (fork() == 0) { /* proceso hijo */ for(;;) { mq_receive(mutex, &c, 1, 0); /* entrada seccion critica */ /* seccion critica */ mq_send(mutex, &c, 1, 0); /* salida seccion critica */ else { /* proceso padre */ for(;;) { mq_receive(mutex, &c, 1, 0); /* entrada seccion critica */ /* seccion critica */ mq_send(mutex, &c, 1, 0); /* salida seccion critica */ Sistemas operativos: una visión aplicada 76 J. Carretero, F. García, P. de Miguel, F. Pérez
77 Productor-consumidor con colas de mensajes #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ mqd_t almacen; /* cola de mensaje donde dejar los datos producidos y recoger los datos a consumir */ void main(void) { struct mq_attr attr; attr.mq_maxmsg = MAX_BUFFER; attr.mq_msgsize = sizeof(int); almacen = mq_open("almacen", O_CREAT O_RDWR, 0777, &attr); if (almacen == -1) { perror("mq_open"); exit(0); Sistemas operativos: una visión aplicada 77 J. Carretero, F. García, P. de Miguel, F. Pérez
78 Productor-consumidor con colas de mensajes (II) if (fork() == 0) /* proceso hijo */ Productor(); else /* proceso padre */ Consumidor(); exit(0); void Productor(void) /* codigo del productor */ { int dato, i; for(i=0; i < DATOS_A_PRODUCIR; i++ ) { dato = i; /* producir dato */ printf("produce %d \n", dato); mq_send(almacen, &dato, sizeof(int), 0); return; Sistemas operativos: una visión aplicada 78 J. Carretero, F. García, P. de Miguel, F. Pérez
79 Productor-consumidor con colas de mensajes (III) /* codigo del consumidor */ void Consumidor(void) { int dato; int i; for(i=0; i < DATOS_A_PRODUCIR; i++ ) { mq_receive(almacen, &dato, sizeof(int), 0); /* cosumir dato */ printf("consume %d \n", dato); return; Sistemas operativos: una visión aplicada 79 J. Carretero, F. García, P. de Miguel, F. Pérez
80 Servidor multithread con colas de mensajes P r o c e s o c l i e n t e P r o c e s o c l i e n t e C o l a d e l C o l a d e l c l i e n t e p e t i c i ó n c l i e n t e P r o c e s o s e r v i d o r p e t i c i ó n r e s p u e s t a C o l a d e l s e r v i d o r C r e a c i ó n d e l t h r e a d r e s p u e s t a C r e a c i ó n d e l t h r e a d T h r e a d q u e s i r v e l a p e t i c i ó n T h r e a d q u e s i r v e l a p e t i c i ó n Sistemas operativos: una visión aplicada 80 J. Carretero, F. García, P. de Miguel, F. Pérez
81 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 */ Sistemas operativos: una visión aplicada 81 J. Carretero, F. García, P. de Miguel, F. Pérez
82 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); Sistemas operativos: una visión aplicada 82 J. Carretero, F. García, P. de Miguel, F. Pérez
83 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); Sistemas operativos: una visión aplicada 83 J. Carretero, F. García, P. de Miguel, F. Pérez
84 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); Sistemas operativos: una visión aplicada 84 J. Carretero, F. García, P. de Miguel, F. Pérez
85 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); Sistemas operativos: una visión aplicada 85 J. Carretero, F. García, P. de Miguel, F. Pérez
86 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)); Sistemas operativos: una visión aplicada 86 J. Carretero, F. García, P. de Miguel, F. Pérez
87 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); Sistemas operativos: una visión aplicada 87 J. Carretero, F. García, P. de Miguel, F. Pérez
88 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 Sistemas operativos: una visión aplicada 88 J. Carretero, F. García, P. de Miguel, F. Pérez
89 Implementación de mecanismos de sincronización Espera activa: wait(s) { s = s 1; while (s < 0) ; signal(s) { s = s + 1; Espera pasiva wait(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; Sistemas operativos: una visión aplicada 89 J. Carretero, F. García, P. de Miguel, F. Pérez
90 Implementación de la espera pasiva Operaciones para bloquear a un proceso en un semáforo T a b l a d e p r o c e s o s E s t a d o P I D B C P 1 B C P 2 B C P 3 B C P 4 B C P 5 B C P 6 B C P 7 B C P 8 B C P 9 B C P 1 0 B C P 1 1 B C P 1 2 B l o q. E j e c C o l a a s o c i a d a a l s e m á f o r o 7 ( a ) T a b l a d e p r o c e s o s E s t a d o P I D B C P 1 B C P 2 B C P 3 B C P 4 B C P 5 B C P 6 B C P 7 B C P 8 B C P 9 B C P 1 0 B C P 1 1 B C P 1 2 B l o q. B l o q. B l o q C o l a a s o c i a d a a l s e m á f o r o ( b ) Sistemas operativos: una visión aplicada 90 J. Carretero, F. García, P. de Miguel, F. Pérez
91 Implementación de la espera pasiva Operaciones para desbloquear a un proceso bloqueado en un semáforo T a b l a d e p r o c e s o s E s t a d o P I D B C P 1 B C P 2 B C P 3 B C P 4 B C P 5 B C P 6 B C P 7 B C P 8 B C P 9 B C P 1 0 B C P 1 1 B C P 1 2 B l o q. B l o q. B l o q C o l a a s o c i a d a a l s e m á f o r o ( a ) T a b l a d e p r o c e s o s E s t a d o P I D B C P 1 B C P 2 B C P 3 B C P 4 B C P 5 B C P 6 B C P 7 B C P 8 B C P 9 B C P 1 0 B C P 1 1 B C P 1 2 L i s t o B l o q. B l o q C o l a a s o c i a d a a l s e m á f o r o 1 1 ( b ) Sistemas operativos: una visión aplicada 91 J. Carretero, F. García, P. de Miguel, F. Pérez
92 Instrucciones hardware especiales Operación atómicas int 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; Sistemas operativos: una visión aplicada 92 J. Carretero, F. García, P. de Miguel, F. Pérez
93 Sección crítica con test-and-set Los procesos comparten la variable lock (con valor inicial a false) while (test-and-set(&lock)) ; <Código de la sección crítica> lock = false; Sistemas operativos: una visión aplicada 93 J. Carretero, F. García, P. de Miguel, F. Pérez
94 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; Sistemas operativos: una visión aplicada 94 J. Carretero, F. García, P. de Miguel, F. Pérez
95 Implementación de un semáforo con test-andset 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; Sistemas operativos: una visión aplicada 95 J. Carretero, F. García, P. de Miguel, F. Pérez
96 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 Sistemas operativos: una visión aplicada 96 J. Carretero, F. García, P. de Miguel, F. Pérez
97 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 P2 wait(p) wait(q) wait(q) wait(p) signal(p) signal(q) signal(q) siangl(p) Sistemas operativos: una visión aplicada 97 J. Carretero, F. García, P. de Miguel, F. Pérez
98 Ejemplo de interbloqueo P A B Q Sistemas operativos: una visión aplicada 98 J. Carretero, F. García, P. de Miguel, F. Pérez
99 Interbloqueos II Ejemplo: Si C1 y C2 son dos colas de mensajes: P1 P2 receive(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 Sistemas operativos: una visión aplicada 99 J. Carretero, F. García, P. de Miguel, F. Pérez
100 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 Sistemas operativos: una visión aplicada 100 J. Carretero, F. García, P. de Miguel, F. Pérez
101 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); Sistemas operativos: una visión aplicada 101 J. Carretero, F. García, P. de Miguel, F. Pérez
102 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. Sistemas operativos: una visión aplicada 102 J. Carretero, F. García, P. de Miguel, F. Pérez
103 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. Sistemas operativos: una visión aplicada 103 J. Carretero, F. García, P. de Miguel, F. Pérez
104 Variables condicionales int pthread_cond_init(pthread_cond_t*cond, pthread_condattr_t*attr); Inicializa una variable condicional. int pthread_cond_destroy(pthread_cond_t *cond); Destruye un variable condicional. int pthread_cond_signal(pthread_cond_t *cond); Se reactivan uno o más de los procesos ligeros que están suspendidos en la variable condicional cond. No tiene efecto si no hay ningún proceso ligero esperando (diferente a los semáforos). int pthread_cond_broadcast(pthread_cond_t *cond); Todos los threads suspendidos en la variable condicional cond se reactivan. No tiene efecto si no hay ningún proceso ligero esperando. int pthread_cond_wait(pthread_cond_t*cond, pthread_mutex_t*mutex); Suspende al proceso ligero hasta que otro proceso señaliza la variable condicional cond. Automáticamente se libera el mutex. Cuando se despierta el proceso ligero vuelve a competir por el mutex. Sistemas operativos: una visión aplicada 104 J. Carretero, F. García, P. de Miguel, F. Pérez
105 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. Sistemas operativos: una visión aplicada 105 J. Carretero, F. García, P. de Miguel, F. Pérez
106 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. Sistemas operativos: una visión aplicada 106 J. Carretero, F. García, P. de Miguel, F. Pérez
SISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 7: Hilos y mecanismos de comunicación y sincronización Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García Blas José Manuel Pérez
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Hilos y mecanismos de comunicación y sincronización
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Hilos y mecanismos de comunicación y sincronización Contenido 2 Comunicación y sincronización. Semáforos. El problema de los lectores escritores.
Más detallesSistemas operativos: una visión aplicada. Capítulo 5 Comunicación y sincronización de procesos
Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos Sistema multiprogramado con un una CPU Proceso A Proceso B Proceso C Tiempo Sistemas operativos: una visión
Más detallesCapítulo 5 Comunicación y sincronización de procesos
Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos Contenido Procesos concurrentes. Problemas clásicos de comunicación y sincronización. Mecanismos de comunicación
Más detalles26/01/2010. Espera activa Semáforos Problemas clásicos de com. y sin. Servicios POSIX
Tema 5: Comunicación y sincronización de procesos Tema 5: Comunicación y sincronización de procesos Comunicación y sincronización acó Espera activa Semáforos Problemas clásicos de com. y sin. Mecanismos
Más detallesComunicación y Sincronizacion de procesos. Ingeniería del Software EUITI UPM. Seccion critica Productor consumidor Lectores escritores
Comunicación y Sincronizacion de procesos Ingeniería del Software EUITI UPM Índice Intro Seccion critica Productor consumidor Lectores escritores Tuberias Semaforos Memoria compartida Mutex y variables
Más detallesComunicación y Sincronizacion de procesos. Ingeniería del Software EUITI UPM
Comunicación y Sincronizacion de procesos Ingeniería del Software EUITI UPM Índice! Intro Seccion critica Productor consumidor Lectores escritores! Tuberias! Semaforos! Memoria compartida! Mutex y variables
Más detallesTema 2 Comunicación y sincronización entre procesos
Tema 2 Comunicación y sincronización entre procesos Grupo ARCOS Grado en Ingeniería Informática Universidad Carlos III de Madrid Contenido Repaso de los conceptos de proceso y threads Concurrencia Mecanismos
Más detallesProcesos ligeros. Arquitectura de Computadores II Universidad Carlos III de Madrid
Procesos ligeros Arquitectura de Computadores II Introducción Programa Archivo ejecutable residente en un dispositivo de almacenamiento permanente Se ejecuta por medio de la llamada exec() Proceso Es un
Más detallesComunicación y sicronización de procesos
4 Comunicación y sicronización de procesos En este capítulo se presentan prácticas relacionadas con la comunicación y sincronización de procesos. El objetivo fundamental es que el alumno entienda el problema
Más detallesNº Mat. Calificación APELLIDOS NOMBRE. CURSO 4º GRUPO Julio 2014 ASIGNATURA: SISTEMAS INFORMÁTICOS INDUSTRIALES
APELLIDOS NOMBRE Nº Mat. UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y DISEÑO INDSUTRIAL Departamento Electrónica, Automática e Informática Industrial 2. Problema de ADOO (10
Más detallesSincronización de Threads
Funciones POSIX III Funciones POSIX III Sincronización Sincronización Procesos Procesos Semáforos Semáforos (sem_t) (sem_t) Sincronización Sincronización Threads Threads Mutex Mutex (pthread_mutex_t) (pthread_mutex_t)
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Desarrollo de servidores concurrentes
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Desarrollo de servidores concurrentes Contenido 2 Servidores de peticiones. Solución basada en procesos. Solución basada en hilos bajo
Más detallesSistemas operativos. Comunicación y sincronización de procesos
Sistemas operativos Comunicación y sincronización de procesos Comunicación y sincronización de procesos Contenido 1. Introducción 2. Comunicación por memoria común 3. El problema de la sección crítica
Más detallesSincronización de procesos
Sincronización de procesos Contenido Procesos concurrentes. El problema de la seccion critica Problemas clásicos de comunicación y sincronización. Mecanismos de comunicación y sincronización. DSO 2014
Más detallesSISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 8: Desarrollo de servidores concurrentes Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García Blas José Manuel Pérez Lobato Introducción
Más detallesSincronización de Hilos POSIX
Sincronización de Hilos POSIX Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Problemática Ejemplo: el problema del productor/consumidor (o del buffer acotado ) Existen
Más detallesTema 4 El paradigma cliente-servidor
Tema 4 El paradigma cliente-servidor F. García-Carballeira, Mª. Soledad Escolar, Luis Miguel Sánchez, Fco. Javier García Sistemas Distribuidos Grado en Ingeniería Informática Universidad Carlos III de
Más detallesAcceso coordinado a recursos compartidos
Programación Concurrente en Linux Acceso coordinado a recursos compartidos Alberto Lafuente, Dep. KAT/ATC de la UPV/EHU, bajo Licencia Creative Commons 1 Contenido 1. Recursos compartidos 2. Mecanismos
Más detallesSistemas Operativos: Programación de Sistemas. Curso Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J.
Tema 5 : Comunicación entre Procesos mediante Tuberías Sistemas Operativos: Programación de Sistemas Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J. Santana Pérez Curso 2006-07 Introducción Algunas
Más detallesRedirecciones y Tuberías
Redirecciones y Tuberías Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Redirecciones Redirección de la entrada y la salida estándar Unix/Linux definen
Más detallesBiblioteca de sistema
* Para la realización del presente examen se aconseja un tiempo de 2 horas. Teoría 1. Explique en detalle cómo se pasa una llamada al sistema operativo. El sistema operativo se activa cuando debe responder
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Procesos concurrentes y problemas en la comunicación y la sincronización
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Procesos concurrentes y problemas en la comunicación y la sincronización Contenido 2 Concurrencia. Condiciones de carrera. Exclusión mutua
Más detallesFundamentos de los Sistemas Operativos
Práctica 3 : hilos! Fundamentos de los Sistemas Operativos Grado en Ingeniería Informática Rubén García Rodríguez Alexis Quesada Arencibia Eduardo Rodríguez Barrera Francisco J. Santana Pérez José Miguel
Más detallesSistemas Operativos sesión 12: tuberías
Sistemas Operativos sesión : tuberías Grado en Ingeniería Informática Universidad Carlos III de Madrid Agenda Linux Comunicación con tuberías Ejercicios Agenda Linux Comunicación con tuberías Ejercicios
Más detallesAnalista Universitario en Sistemas. Sistemas Operativos. Instituto Politécnico Superior THREADS
THREADS 1 Introducción Los procesadores actuales permiten realizar muchas tareas en simultáneo En los sistemas la ejecución de las tareas puede intercalarse en un sólo procesador, y en casos de multi-procesadores,
Más detallesTaller de Programación Paralela
Taller de Programación Paralela Departamento de Ingeniería Informática Universidad de Santiago de Chile April 4, 2008 y sincronización Cuando dos o más tareas (procesos o hebras) comparten algún recurso
Más detallesSISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 6: Procesos concurrentes y problemas en la comunicación y la sincronización Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García
Más detallesInformática Electrónica Concurrencia
Informática Electrónica Concurrencia DSI- EIE FCEIA 2015 Que es concurrencia? Ejecución simultánea de dos o mas aplicaciones en una única plataforma de cómputo DSI EIE - FCEIA Informática Electrónica 2
Más detallesFormatos para prácticas de laboratorio
CARRERA PLAN DE ESTUDIO CLAVE ASIGNATURA NOMBRE DE LA ASIGNATURA IC 2003-1 5314 Sistemas Operativos PRÁCTICA No. 6 LABORATORIO DE NOMBRE DE LA PRÁCTICA Comunicación entre procesos Tuberías DURACIÓN (HORA)
Más detallesTaller de Programación Paralela
Taller de Programación Paralela Departamento de Ingeniería Informática Universidad de Santiago de Chile April 26, 2007 Concurrencia 2 Concurrencia y sincronización.............................................................
Más detallesISO Tema 8,
ISO Tema 8, 2017-2018 Pablo González Nalda Depto. de Lenguajes y Sistemas Informáticos 13 de abril de 2018 Modificado el 27 de abril de 2018 de la presentación 1 2 3 4 5 6 7 2 / 32 1 2 3 4 5 6 7 3 / 32
Más detallesSISTEMAS OPERATIVOS Manejo de procesos
SISTEMAS OPERATIVOS Manejo de procesos Amilcar Meneses Viveros ameneses@computacion.cs.cinvestav.mx Universidad de Occidente Presentación Concepto de proceso Despacho de procesos Operaciones sobre procesos
Más detallesPráctica 1: Intérprete de mandatos. Sistemas Operativos Área de Arquitectura y Tecnología de Computadores
Práctica 1: Intérprete de mandatos Introducción Desarrollo de un intérprete de mandatos (minishell) en UNIX/Linux en lenguaje C. Debe permitir: Ejecución de mandatos simples ls, cp, mv, rm, etc. Ejecución
Más detallesASIGNATURA: SISTEMAS INFORMÁTICOS INDUSTRIALES. CURSO 4º GRUPO Diciembre 2013
APELLIDOS NOMBRE Nº Mat. UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y DISEÑO INDSUTRIAL Departamento Electrónica, Automática e Informática Industrial 2. Problema de ADOO (10
Más detallesSISTEMAS OPERATIVOS AVANZADOS
SISTEMAS OPERATIVOS AVANZADOS TEMA 3 CLAVE: MIS 204 PROFESOR: M.C. ALEJA DRO GUTIÉRREZ DÍAZ 3. PROCESOS CONCURRENTES 3.1 Conceptos de programación concurrente 3.2 El problema de la sección crítica 3.3
Más detallesFunciones POSIX III Funciones POSIX III. No Nombrados Nombrados. sem_open sem_open. sem_close sem_close. sem_unlink sem_unlink
Funciones POSIX III Funciones POSIX III Sincronización Sincronización Procesos Procesos Semáforos Semáforos (sem_t) (sem_t) Sincronización Sincronización Threads Threads Mutex Mutex (pthread_mutex_t) (pthread_mutex_t)
Más detallesConcurrencia Monitores. Guillermo Román Díez
Concurrencia Monitores Guillermo Román Díez groman@fi.upm.es Universidad Politécnica de Madrid Curso 2016-2017 Guillermo Román, UPM CC: Monitores 1/25 Recursos Compartidos Pregunta La especificación de
Más detallesProgramación Concurrente
Master en Computación Programación Concurrente Bloque II: Programación concurrente en POSIX Tema 1. Introducción al estándar POSIX Tema 2. Sistema Operativo MaRTE OS Tema 4. Gestión del Tiempo Tema 5.
Más detallesSincronizacion de procesos
Sincronizacion de procesos Sobre los procesos cooperantes: Pueden compartir espacios de direcciones o datos a través de un archivo. Problema a considerar: Como evitar la inconsistencia de los datos compartidos
Más detallesBloque I: Principios de sistemas operativos
Bloque I: Principios de sistemas operativos Tema 1. Principios básicos de los sistemas operativos Tema 2. Concurrencia Tema 3. Ficheros Tema 4. Sincronización y programación dirigida por eventos Tema 5.
Más detallesEstados de un proceso
Semáforos Estados de un proceso Inactivo Listo Ejecutando Completo Escribimos p.state := ready p. state := running Bloqueado Para indicar que un proceso cambia de estado Semáforo Es un tipo de dato abstracto
Más detallesConcurrencia, exclusión mutua y sincronización. Capítulo 5 HungriaBerbesi
Concurrencia, exclusión mutua y sincronización Capítulo 5 HungriaBerbesi 1 Concurrencia Múltiples aplicaciones Aplicaciones estructuradas Estructura del sistema operativo 2 Concurrencia 3 Sección Crítica:
Más detallesMC Hilda Castillo Zacatelco PROCESOS
MC Hilda Castillo Zacatelco hildacz@gmail.com PROCESOS Definición y atributos Un proceso es la instancia de un programa en ejecución. Desde el punto de vista del SO, un proceso es la entidad más pequeña
Más detallesPROGRAMACIÓN MULTITHREADING
ECAR 2012 PROGRAMACIÓN MULTITHREADING 1 PROGRAMACIÓN BÁSICA PROGRAMACIÓN MULTITHREADING Sergio Nesmachnow (sergion@fing.edu.uy) Gerardo Ares (gares@fing.edu.uy) Escuela de Computación de Alto Rendimiento
Más detallesTema 3. Concurrencia entre procesos
Tema 3. SO Índice Procesamiento concurrente El problema de la sección crítica Semáforos Mutex y variables de condición Señales Paso de mensajes Monitores Mecanismos de concurrencia en sistemas Unix Mecanismos
Más detallesPrácticas de Sistemas operativos
Prácticas de Sistemas operativos David Arroyo Guardeño Escuela Politécnica Superior de la Universidad Autónoma de Madrid Tercera Semana: Comunicación entre procesos con Tuberías 1 Entregas 2 Introducción
Más detallesComunicación entre Procesos
Sincronización y Comunicación de Procesos Sincronización y Comunicación de Procesos Sincronización Sincronización Comunicación Comunicación Condiciones de Condiciones de Carrera Carrera Memoria Memoria
Más detallesUnidad 1: Gestión de Procesos
Unidad 1: Gestión de Procesos Tema 1, Concurrencia: Exclusión mutua y sincronización. 1.1 Problema de la sección crítica, alternativas al uso de semáforos: - Regiones críticas, Monitores, Variables de
Más detallesInformática I Threads
Informática I Threads 28 de Setiembre 2010 1 Concepto de programación paralela. 2. 3 Concurrencia => Race Conditions. 4. 5 Funciones Concepto de Programación Paralela Computación paralela Técnica de programación
Más detallesProgramación Concurrente Recopilación de teoría referente a la materia
UNIVERSIDAD AMERICANA Programación Concurrente Recopilación de teoría referente a la materia Ing. Luis Müller Esta es una recopilación de la teoría referente a la asignatura Programación Concurrente, a
Más detallesSi un candado mutex es usado por hilos en el mismo proceso pero no por hilos en diferentes procesos, los primeros dos pasos pueden simplificarse a:
Pthreads La biblioteca también soporta candados y variables de condición. Los candados pueden usarse para proteger la sección crítica, o pueden usarse en combinación con las variables de condición para
Más detallesASIGNATURA: SISTEMAS INFORMÁTICOS INDUSTRIALES. CURSO 4º GRUPO Enero 2016
APELLIDOS NOMBRE Nº Mat. UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y DISEÑO INDSUTRIAL Departamento de Ingeniería Eléctrica, Electrónica, Automática y Física Aplicada ASIGNATURA:
Más detallesEjercicios sobre tuberías
Boletín 3. Ejercicios sobre tuberías July 14, 016 1. Indica de manera justificada si las siguientes afirmaciones sobre la utilización de tuberías como mecanismo de sincronización entre dos procesos son
Más detallesPlataformas de Tiempo Real
Master en Computación Plataformas de Tiempo Real POSIX Avanzado y Extensiones Tema 2. Gestión de Interrupciones en MaRTE OS Tema 3. Monitorización y control del tiempo de ejecución Tema 4. Planificación
Más detallesProcesos e hilos: cálculo de
Departamento de Automática 1 / 10 Índice Creación y sincronización de hilos Acceso a variables globales en exclusión mutua 2 / 10 Objetivo principal: obtener una aproximación al valor de empleando el método
Más detallesInterbloqueo. Concurrencia: Interbloqueo e Inanición
Interbloqueo Concurrencia: Interbloqueo e Inanición Capítulo 6 Bloqueo permanente de un conjunto de procesos que compiten por recursos del sistema o por comunicación con los otros No existe una solución
Más detallesComunicación y sincronización
Comunicación y sincronización Son conceptos relacionados con la interacción entre los procesos La comunicación se refiere al paso de información de un proceso a otro La sincronización corresponde al cumplimiento
Más detalles*** SOLUCIONES *** SISTEMAS OPERATIVOS Examen Parcial 24 de Abril de 2010
Calificación SISTEMAS OPERATIVOS Examen Parcial 24 de Abril de 2010 1 2 3 4 Nombre *** SOLUCIONES *** Titulación Dispone de tres horas para realizar el examen 1 (5 puntos) Test. En cada uno de los siguientes
Más detallesPlataformas de Tiempo Real
Master en Computación Plataformas de Tiempo Real POSIX Avanzado y Extensiones Tema 1. Ficheros y entrada/salida Tema 3. Monitorización y control del tiempo de ejecución Tema 4. Planificación EDF Tema 5.
Más detallesSistemas Operativos 1
Ejercicio 1. Se desea implementar una aplicación de n procesos concurrentes, donde cada proceso ejecuta una determinada tarea en forma de pipeline. Un ejemplo de esta aplicación con n=4 sería la siguiente:
Más detallesExamen Final de SO Grau
Preguntas cortas 1. (0,5 puntos) Asumiendo que ninguna llamada devuelve error, representa las entradas nuevas de la TFA que aparecerán tras la ejecución del siguiente código: fork(); mknod( pipe, S_IFIFO
Más detallesEntrada y Salida de Archivos
Entrada y Salida de Archivos E/S Básica de Archivo El servicio básico es sin buffering, a diferencias de la E/S estándar (stdio.h), dado que las primeras generan llamadas al sistema (read y write). Son
Más detallesA2. Diseñar una solución basada en varios procesos pesados emparentados, cada uno de los cuáles procesará una parte de los votos.
Sistemas Operativos 4o Semestre GII & GMI Cuarto Parcial. Comunicación y Sincronización. 1 de Junio de 2015 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Más detallesSistemas operativos. Hasta ahora hemos visto. Relación programa-sistema operativo Gestión de memoria
Sistemas operativos UPCO ICAI Departamento de Electrónica y Automática 1 Hasta ahora hemos visto Relación programa-sistema operativo Gestión de memoria Reserva para la ejecución Pilas, heap, memoria de
Más detallesFunciones POSIX (I): Introducción
Funciones POSIX I Funciones POSIX I Llamadas al Llamadas al Sistema Sistema Gestión Básica Gestión Básica de Procesos de Procesos Procesos Procesos fork fork Señales Señales getpid getpid Memoria Memoria
Más detallesHilos de ejecución POSIX
Hilos de ejecución POSIX Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Hilos de ejecución Concepto Un proceso convencional se caracteriza por: Ser
Más detallesConcurrencia de Procesos
Concurrencia de Procesos Dos o mas procesos, se dice que son concurrentes o paralelos, cuando se ejecutan al mismo tiempo. Esta concurrencia puede darse en un sistema con un solo procesador (pseudo paralelismo)
Más detallesSistemas Operativos. Procesos
Sistemas Operativos Procesos Agenda Proceso. Definición de proceso. Contador de programa. Memoria de los procesos. Estados de los procesos. Transiciones entre los estados. Bloque descriptor de proceso
Más detallesUNIVERSIDAD CARLOS III DE MADRID AREA DE ARQUITECTURA Y TECNOLOGÍA DE COMPUTADORES GRADO EN INGENIERÍA INFORMÁTICA. SISTEMAS DISTRIBUIDOS
UNIVERSIDAD CARLOS III DE MADRID AREA DE ARQUITECTURA Y TECNOLOGÍA DE COMPUTADORES GRADO EN INGENIERÍA INFORMÁTICA. SISTEMAS DISTRIBUIDOS Para la realización del presente examen se dispondrá de 2 horas
Más detallesSegundo control de teoría Q1
Segundo control de teoría --Q JUSTIFICA TODAS LAS RESPUESTAS. UNA RESPUESTA SIN JUSTIFICAR SE CONSIDERA INVALIDA EJERCICIO : Preguntas cortas ( puntos) ) En un sistema de ficheros basado en inodos a) Explica
Más detallesSegundo control de teoría
Preguntas cortas. Contesta y justifica TODAS las preguntas en el espacio asignado (0,5 cada pregunta) a) Qué consecuencias tendría en la cantidad de accesos a disco eliminar la Tabla de Inodos? b) Qué
Más detallesdit Programación concurrente Sincronización condicional UPM
20151028 dit UPM Programación concurrente Sincronización condicional Juan Antonio de la Puente Algunos derechos reservados. Este documento se distribuye bajo licencia Crea9ve Commons
Más detallesCapítulo 2 Introducción a los sistemas operativos
Sistemas operativos: una visión aplicada Capítulo 2 Introducción a los sistemas operativos Contenido Qué es un sistema operativo? Arranque del computador Componentes y estructura de un sistema operativo
Más detallesLecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1
Semáforos Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1 Manuel Carro Universidad Politécnica de Madrid Este texto se distribuye bajo los términos de la Creative Commons
Más detalles1. Interfaz de llamadas a la librería de fluxes
1. Interfaz de llamadas a la librería de fluxes Se presenta a continuación un interfaz de threads de usuario construido sobre los PThreads de OSF/1 (sistema operativo de alabi/alaba). El motivo de no utilizar
Más detallesSincronización de Procesos
Sincronización de Procesos Departamento de Ciencias e Ingeniería de la Computación Universidad Nacional del Sur Sincronización de Procesos Fundamentos El Problema de la Sección Crítica Solución a la sección
Más detallesIntroducción a Sistemas Operativos: Concurrencia
Introducción a Sistemas Operativos: Concurrencia Clips xxx Fr ancisco J Ballesteros 1. Semáforos Quizá la abstracción más conocida para sincronizar procesos en programación concurrente controlar el acceso
Más detallesClases 04 y 05: Repaso de programación de sistemas basados en UNIX
Clases 04 y 05: Repaso de programación de sistemas basados en UNIX Prof. Edgardo Adrián Franco Martínez http://computacion.cs.cinvestav.mx/~efranco efranco.docencia@gmail.com Estructuras de datos (Prof.
Más detallesLlamadas a Sistema para procesos
Llamadas a Sistema para procesos SistOp 2012 Nicolás Wolovick FaMAF, Universidad Nacional de Córdoba, Argentina 5 de Septiembre de 2012 El Cajón de Arena: los procesos Comandos simples con y sin background
Más detallesLecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1. Exclusión mutua con semáforos
Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1 Manuel Carro Universidad Politécnica de Madrid Este texto se distribuye bajo los términos de la Creative Commons License
Más detallesExamen Final de Teoría. Grupo de teoría:
Preguntas Cortas (2 puntos) 1. Respecto a la optimización de gestión de memoria CoW, explica brevemente: a. Qué soporte hardware utiliza el sistema para poder implementarla? b. Qué permisos aplica el sistema
Más detallesTaller de pthreads. Sistemas Operativos. Verano de 2009
Verano de 2009 Menú del día Hoy veremos: Introducción a pthreads Creación de threads Variables mutex Variables de condición Tutoriales de HPC Lawrence Livermore National Laboratory (http://www.llnl.gov)
Más detallesMensajes. Interbloqueo
CONCURRENCIA DE PROCESOS Preparado por: Angel Chata Tintaya (angelchata@hotmail.com) Resumen Los procesos comparten variables globales, comparten y compiten por recursos, se ejecutan simultáneamente intercalándose
Más detallesTema 4: Gestión de Procesos
Tema 4: Gestión de Procesos SSOO - Curso 2005/06 E. Domínguez C. Villarrubia Departamento de Tecnologías y Sistemas de Información Escuela Superior de Informática Universidad de Castilla - La Mancha Marzo
Más detallesUnidad 2: Gestión de Procesos
Unidad 2: Gestión de Procesos Tema 6, Concurrencia: Exclusión mutua y sincronización. 6.1 Principios generales de concurrencia. 6.2 EM: Soluciones software (Algoritmos de Dekker y Peterson). 6.3 EM: Soluciones
Más detallesConcurrencia. Primitivas IPC con bloqueo
Concurrencia Primitivas IPC con bloqueo Primitivas de IPC con bloqueo La solución de Peterson es correcta, pero tiene el defecto de requerir espera ocupada: Cuando un proceso quiere entrar en su región
Más detallesSistemas Operativos II Junio 2006 Nombre:
Sistemas Operativos II Junio 2006 Nombre: ITIS Castellano Ejercicio 1 [1 punto] 1. Por qué es más eficiente el cambio de contexto entre threads (hilos) que entre procesos? 2. Describe brevemente la diferencia
Más detallesSegundo control de teoría
JUSTIFICA TODAS LAS RESPUESTAS. UNA RESPUESTA SIN JUSTIFICAR SE CONSIDERA INVALIDA EJERCICIO 1: Preguntas cortas ( puntos) 1) En un sistema de ficheros basado en inodos a) Explica qué relación hay entre
Más detallesFunción monitoreo descriptor archivo #include <sys/types.h> #include<unistd.h> #include<errno.h> extern void procesamiento_datos(char *, int); void pr
Introducción al concepto de threads Dr.. Roberto Gómez Cárdenas DCC del ITESM-CEM rogomez@itesm.mx http://homepage.cem.itesm.mx/rogomez Función monitoreo descriptor archivo #include #include
Más detallesSemáforos. Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1. Exclusión mutua con semáforos
Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1 Manuel Carro Universidad Politécnica de Madrid Este texto se distribuye bajo los términos de la Creative Commons License
Más detallesT5-multithreading. Indice
T5-multithreading 1.1 Indice Proceso vs. Flujos Librerías de flujos Comunicación mediante memoria compartida Condición de carrera Sección Crítica Acceso en exclusión mutua Problemas Abrazos mortales 1.2
Más detallesArquitectura de Computadores. Práctica 3: Mecanismos de comunicación entre procesos
- 1 - Arquitectura de Computadores Práctica 3: Mecanismos de comunicación entre procesos Miguel Martínez de Falcón Pérez Mikel Anthony Rodríguez Manderson - 2-1) TUBERÍAS SIN NOMBRE a) Para comprobar su
Más detallesConcurrencia: deberes. Concurrencia: Exclusión Mutua y Sincronización. Concurrencia. Dificultades con la Concurrencia
Concurrencia: deberes Concurrencia: Exclusión Mutua y Sincronización Capítulo 5 Comunicación entre procesos Compartir recursos Sincronización de múltiples procesos Asignación del tiempo de procesador Concurrencia
Más detallesProgramación Concurrente
Master en Computación Programación Concurrente Bloque II: Programación concurrente en POSIX Tema 1. Introducción al estándar POSIX Tema 2. Sistema Operativo MaRTE OS Tema 3. Gestión de Threads Tema 4.
Más detallesNombre Apellidos. DNI Titulación Grupo.
Sistemas Operativos. 6 de septiembre de 2006 Nombre Apellidos. DNI Titulación Grupo. TEORÍA 1. (Ficheros) 2 puntos a) Indique qué información de un fichero se guarda en una entrada de directorio en un
Más detallesTema 3. Concurrencia entre procesos
Tema 3. S O Índice Procesamiento concurrente El problema de la sección crítica Problemas clásicos de comunicación y sincronización Mutex y variables de condición Tuberías Mª Asunción Castaño 1 Tema 3.
Más detallesExamen de Programación Concurrente - Clave: a Junio 2008 Departamento de Lenguajes, Sistemas Informáticos e Ingeniería del Software.
Junio 2008 Programación Concurrente 1/6 Normas Examen de Programación Concurrente - Clave: a Junio 2008 Departamento de Lenguajes, Sistemas Informáticos e Ingeniería del Software Este examen es un cuestionario
Más detalles