SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Hilos y mecanismos de comunicación y sincronización
|
|
- Elena Bustos Robles
- hace 6 años
- Vistas:
Transcripción
1 SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Hilos y mecanismos de comunicación y sincronización
2 Contenido 2 Comunicación y sincronización. Semáforos. El problema de los lectores escritores. Solución con semáforos. Mutex y variables condición.
3 Mecanismos de comunicación 3 Los mecanismos de comunicación permiten la transferencia de información entre dos procesos. Archivos Tuberías (pipes, FIFOS) Variables en memoria compartida Paso de mensajes
4 Mecanismos de sincronización 4 Los mecanismos de sincronización permiten forzar a un proceso a detener su ejecución hasta que ocurra un evento en otro proceso. 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
5 Semáforos POSIX 5 Mecanismo de sincronización para procesos y/o threads en la misma máquina Semáforos POSIX de dos tipos: Semáforos con nombre: puede ser usado por distintos procesos que conozcan el nombre. No requiere memoria compartida. Semáforos sin nombre: pueden ser usados solo por el procesos que los crea (y sus threads) o por procesos que tengan una zona de memoria compartida. #include <semaphore.h> sem_t *semaforo; //nombrados sem_t semaforo; // no nombrado
6 Semáforos POSIX 6 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_trywait (sem_t *sem) Intenta hacer wait, pero si está bloqueado vuelve sin hacer nada y da -1 int sem_post(sem_t *sem); Realiza la operación signal sobre un semáforo.
7 Secciones críticas con semáforos 7 sem_wait(s); /* entrada en la seccion critica */ < seccion critica > sem_post (s); /* salida de la seccion critica */ El semáforo debe tener valor inicial 1 o superior 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
8 Operaciones sobre semáforos 8 sem_wait(s) { s = s - 1; if (s <= 0) { <Bloquear al proceso> sem_post(s) { s = s + 1; if (s > 0) <Desbloquear a un proceso bloqueado por la operacion wait>
9 Semáforos sin nombre. Ejemplo: Productor-consumidor. 9 #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); Productor Consumidor
10 Productor-consumidor con semáforos 10 /* 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);
11 Semáforos sin nombre. Productor-consumidor: Hilo productor 11 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);
12 Semáforos sin nombre. Productor-consumidor: Hilo consumidor 12 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);
13 Problema de los lectores-escritores 13 Problema que se plantea cuando se tiene un área de almacenamiento compartida. Múltiples procesos leen información. Múltiples procesos escriben información. Lector Lector Escritor Lector Escritor Condiciones: Cualquier número de lectores pueden leer de la zona de datos concurrentemente. Solamente un escritor puede modificar la información a la vez. Durante una escritura ningún lector puede realizar una consulta. Recurso
14 Diferencias con otros problemas 14 Exclusión mutua: En el caso de la exclusión mutua solamente se permitiría a un proceso acceder a la información. No se permitiría concurrencia entre lectores. Productor consumidor: En el productor/consumidor los dos procesos modifican la zona de datos compartida. Objetivos de restricciones adicionales: Proporcionar una solución más eficiente.
15 Alternativas de gestión 15 Los lectores tienen prioridad. Si hay algún lector en la sección crítica otros lectores pueden entrar. Un escritor solamente puede entrar en la sección crítica si no hay ningún proceso. Problema: Inanición para escritores. Los escritores tienen prioridad. Cuando un escritor desea acceder a la sección crítica no se admite la entrada de nuevos lectores.
16 Los lectores tienen prioridad 16 int nlect; semaforo lec=1; semaforo = escr=1; Lector for(;;) { semwait(lec); nlect++; if (nlect==1) semwait(escr); semsignal(lec); Escritor for(;;) { semwait(escr); realizar_escr(); semsignal(escr); realizar_lect(); semwait(lec); nlect--; if (nlect==0) semsignal(escr); semsignal(lec);
17 17 Semáforos sin nombre. Lectores-escritores con semáforos int dato = 5; /* recurso */ int n_lectores = 0; /* num lectores */ sem_t sem_lec; /* control el acceso n_lectores */ sem_t mutex; acceso a dato */ void main(void) { /* controlar el 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); 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);
18 Semáforos sin nombre. Lectores-escritores:Hilo lector y escritor 18 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); void Escritor(void) { /* codigo del escritor */ sem_wait(&mutex); dato = dato + 2; /* modificar el recurso */ sem_post(&mutex); pthread_exit(0);
19 Semáforos con nombre Nombrado 19 Permiten sincronizar procesos distintos sin usar memoria compartida. El nombre de un sema foro es una cadena de caracteres (con las mismas restricciones de un nombre de fichero). Si el nombre (ruta) es relativa, solo puede acceder al sema foro el proceso que lo crea y sus hijos. Si el nombre es absoluto (comienza por / ) el sema foro puede ser compartido por cualquier proceso que sepa su nombre y tenga permisos. Mecanismo habitual para crear semáforos que comparten padres e hijos Los sin nombre no valen -> los procesos NO comparten memoria.
20 Semáforos con nombre Creación y uso 20 Para crearlo: sem_t *sem_open(char *name, int flag, mode_t mode,int val); Flag = O_CREAT lo crea. Flag: O_CREAT O_EXECL. Lo crea si no existe. -1 en caso de que exista. Mode: permisos de acceso; Val: valor incial del semáforo (>=0); Para usarlo: sem_t *sem_open(char *name, int flag); Con flag 0. Si no existe devuelve -1. Importante: Todos los procesos deben conocer name y usar el mismo.
21 21 Semáforos con nombre: Lectores - Escritores int dato = 5; /* recurso */ int n_lectores = 0; /* num lectores */ sem_t *sem_lec; sem_t *mutex; int main (int argc, char *argv[]) { int i, n= 5; pid_t pid; /* Crea el semáforo nombrado */ if((mutex=sem_open("/tmp/sem_1", O_CREAT, 0644, 1))==(sem_t *)-1) { perror("no se puede crear el semaforo"); exit(1); if((sem_lec=sem_open("/tmp/sem_2", O_CREAT, 0644, 1))==(sem_t *)-1) { perror("no se puede crear el semraáforo"); exit(1); /* Crea los procesos */ for (i = 1; i< atoi(argv[1]); ++i){ pid = fork(); if (pid ==-1) { perror("no se puede crear el proceso"); exit(-1); else if(pid==0) { /child lector(getpid()); break; escritor(pid); /* parent */ sem_close(mutex); sem_close(sem_lec); sem_unlink("/tmp/sem_1"); sem_unlink("/tmp/sem_2");
22 22 Semáforos con nombre: Procesos lectores y escritores void lector (int pid) { sem_wait(sem_lec); n_lectores = n_lectores + 1; if (n_lectores == 1) sem_wait(mutex); sem_post(sem_lec); printf( lector %d dato: %d\n", pid, dato); /* leer dato */ sem_wait(sem_lec); n_lectores = n_lectores - 1; if (n_lectores == 0) sem_post(mutex); sem_post(sem_lec); void escritor (int pid) { sem_wait(mutex); dato = dato + 2; el recurso */ /* modificar printf("escritor %d dato: %d\n", pid, dato); /* leer dato */ sem_post(mutex);
23 Mutex y variables condicionales 23 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.
24 Secciones críticas con mutex 24 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 Proceso ligero B lock mutex lock mutex Sección crítica unlock mutex obtiene mutex Proceso ligero ejecutando Proceso ligero bloqueado Punto de sincronización
25 Variables condicionales 25 Variables de sincronización asociadas a un mutex 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 Conveniente ejecutarlas entre lock y unlock
26 Variables condicionales 26 Proceso ligero A Proceso ligero B lock lock wait Adquiere el mutex unlock mutex Se compite por el mutex Adquiere el mutex signal unlock Proceso ligero bloqueado esperando unlock Proceso ligero bloqueado esperando signal
27 Uso de mutex y variables condicionales 27 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
28 Servicios POSIX 28 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.
29 Servicios POSIX 29 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.
30 Productor consumidor con mutex 30 #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ pthread_mutex_t mutex; /* mutex de 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, Sistemas Operativos.- Hilos NULL); y Sincronización
31 Productor-consumidor con mutex 31 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);
32 Productor 32 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);
33 Consumidor 33 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);
34 Lectores-escritores con mutex 34 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 acceso 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, Sistemas Operativos.- NULL, Hilos Escritor, y Sincronización NULL);
35 Lectores-escritores con mutex 35 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);
36 Escritor 36 void Escritor(void) { /* codigo del escritor */ pthread_mutex_lock(&mutex); dato = dato + 2; /* modificar el recurso */ pthread_mutex_unlock(&mutex); pthread_exit(0);
37 Lector 37 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);
38 SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Mecanismos de comunicación y sincronización
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 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 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 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 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 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 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 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 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 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 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 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 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 detallesSistemas Operativos Práctica 4
Sistemas Operativos Práctica 4 Ing. Andrés Bustamante afbustamanteg@unal.edu.co Ingeniería de Sistemas Facultad de Ingeniería Universidad de la Amazonia 2009 1. Objetivo El objetivo de la práctica es que
Más detallesImplementación de monitores POSIX
Implementación de monitores POSIX Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Programación concurrente: Problemática Presencia de condiciones de
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 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 detallesSistemas Operativos Ingeniería de telecomunicaciones Sesión 3: Concurrencia
Sistemas Operativos Ingeniería de telecomunicaciones Sesión 3: Concurrencia Calendario Comienzo: Lunes 2 de noviembre y miércoles 4 de noviembre. Entrega: 16 de noviembre y 18 de noviembre. 1. Requisitos
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 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 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 detallesSOLUCIONES A ALGUNOS DE LOS EJERCICIOS DE SINCRONIZACION Y COMUNICACION ENTRE PROCESOS
SOLUCIONES A ALGUNOS DE LOS EJERCICIOS DE SINCRONIZACION Y COMUNICACION ENTRE PROCESOS 1. Con las tres llamadas create, suspend, y resume, la estructura del programa sería la siguiente: process recoger;
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 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 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 detallesConcurrencia en UNIX / LINUX. Introducción: Procesos e Hilos POSIX
Concurrencia en UNIX / LINUX Introducción: Procesos e Hilos POSIX El estándar POSIX POSIX: Interfaz de sistemas operativos portables. Basado en UNIX A pesar de que UNIX es ya de por sí estándar, había
Más detallesThreads. Hilos - Lightweight process - Procesos ligeros
Threads Hilos - Lightweight process - Procesos ligeros 1 Temario Concepto y Beneficios Estructuras de implementación: Servidor- Trabajador, Equipo, Pipeline Reconocimiento: En el espacio del usuario /
Más detallesIngeniería Informática. Curso 3º. Sistemas Operativos Examen Final. TEORIA. 4 de Septiembre de 2009
Ingeniería Informática. Curso 3º. Sistemas Operativos Examen Final. TEORIA. 4 de Septiembre de 2009 1. [PROCESOS] a) Considerar el siguiente código: void main() { int j=10; pid_t pid; for (int i=0; i
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 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 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 detallesSISTEMAS OPERATIVOS I (Sistemas) / SISTEMAS OPERATIVOS (Gestión) septiembre 2009
SISTEMAS OPERATIVOS I (Sistemas) / SISTEMAS OPERATIVOS (Gestión) septiembre 2009 4. (2 p) Dos procesos A y B se ejecutan concurrentemente en un determinado sistema. El proceso A ejecuta unas tareas ( Tareas
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 detallesSistemas Operativos Práctica 3
Sistemas Operativos Práctica 3 Ing. Andrés Bustamante afbustamanteg@unal.edu.co Ingeniería de Sistemas Facultad de Ingeniería Universidad de la Amazonia 2009 1. Objetivo El objetivo de la práctica es que
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 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 detallesCDI Exclusión mutua a nivel alto. conceptos
conceptos El concepto de usar estructuras de datos a nivel alto libera al programador de los detalles de su implementación. El programador puede asumir que las operaciones están implementadas correctamente
Más detallesTest SITR Temas: Planificación, Sincronización, Comunicación entre Procesos, Relojes, Señales, Temporizadores (TestSITR_T4 T9)
Test SITR Temas: Planificación, Sincronización, Comunicación entre Procesos, Relojes, Señales, Temporizadores (TestSITR_T4 T9) Temas: Planificación Sincronización y Comunicación entre Procesos Funciones
Más detallesUNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA FACULTAD DE CIENCIAS PRACTICA DE PROCESOS HERRAMIENTAS
UNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA FACULTAD DE CIENCIAS PRACTICA DE PROCESOS HERRAMIENTAS Caso 1: 1.- Necesitamos un cd o Dvd para grabar alguna de las versiones de livecd de Linux. 2.- Liga de una
Más detallesPrueba de Laboratorio Modelo B01 Semáforos y Memoria Compartida
Prueba de Laboratorio APELLIDOS: NOMBRE: GRUPO DE LABORATORIO: Indicaciones: No se permiten libros, apuntes ni teléfonos móviles. Cuando tenga una solución al ejercicio muéstrela al profesor (compilación
Más detallesEstándares POSIX. Estándares base
Estándares POSIX Estándares base. ntaxis y semántica con diversos aspectos del sistema operativo No especifica la implementación La mayoría basados en el lenguaje C Interfaces en diferentes lenguajes Los
Más detallesUNIVERSIDAD CARLOS III DE MADRID DEPARTAMENTO DE INFORMÁTICA INGENIERÍA EN INFORMÁTICA. ARQUITECTURA DE COMPUTADORES II 10 junio de 2006
UNIVERSIDAD CARLOS III DE MADRID DEPARTAMENTO DE INFORMÁTICA INGENIERÍA EN INFORMÁTICA. ARQUITECTURA DE COMPUTADORES II 10 junio de 2006 Para la realización del presente examen se dispondrá de 2 horas
Más detallesProcesos e Hilos en C
Procesos e Hilos en C 6 de febrero de 2012 En esta sesión vamos a escribir programas en lenguaje C que utilicen hilos y procesos para comparar el rendimiento del sistema ante la gestión de unos y otros.
Más detallesConcurrencia: Exclusión mutua y Sincronización
Concurrencia: Exclusión mutua y Sincronización Prof. Carlos Figueira Basado en materiales de Yudith Cardinale (USB) Williams Stallings, Eugene Styer Concurrencia Múltiples aplicaciones Aplicaciones estructuradas
Más detallesSIMM: TEORÍA DE LOS S.O. I.E.S. JUAN DE LA CIERVA CURSO 2007/2008
SIMM: TEORÍA DE LOS S.O. I.E.S. JUAN DE LA CIERVA CURSO 2007/2008 1.- INTRODUCCIÓN A LOS PROCESOS 1.1.- Concepto 1.2.- Composición y estructura 1.3.- Estados y transiciones 2.- COMUNICACIÓN ENTRE PROCESOS
Más detallesDepartamento de Lenguajes y Ciencias de la Computación Universidad de Málaga. Sistemas Operativos. Tema 2: Introducción a la programación concurrente
Departamento de Lenguajes y Ciencias de la Computación Universidad de Málaga Sistemas Operativos Tema 2: Introducción a la programación concurrente Curso 2004/2005 E.T.I. Informática Gestión Profesor:
Más detallesTema 3: Concurrencia de procesos
Tema 3: Concurrencia de procesos Yolanda Blanco Fernández yolanda@det.uvigo.es Concurrencia, Tiempo Real y Paralelismo Concurrencia: Convivencia de un conjunto de procesos en un mismo ordenador. Sistemas
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 detallesExamen final de teoría QT
JUSTIFICA TODAS LAS RESPUESTAS. UNA RESPUESTA SIN JUSTIFICAR SE CONSIDERA INVALIDA Preguntas cortas (1,5 puntos) 1. Un hardware que ofrece cuatro modos de ejecución, uno de ellos de usuario y tres niveles
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 I Manual de prácticas
Sistemas Operativos I Manual de prácticas Grupo de Sistemas Operativos (DSIC/DISCA) Práctica 3: Procesos POSIX ANTES DE EMPEZAR...... 2 PRÁCTICA 3: PROCESOS POSIX... 2 CREACIÓN DE PROCESOS MEDIANTE FORK...
Más detallesSistemas Operativos I. Enxeñería Informática. Curso 2007/08. Práctica 2: Concurrencia de procesos: Productores/Consumidores.
Sistemas Operativos I. Enxeñería Informática. Curso 2007/08. Práctica 2: Concurrencia de procesos: Productores/Consumidores. En esta práctica se tratará de resolver el problema de los productores/consumidores
Más detallesPROGRAMACIÓN CONCURRENTE. Tema 5 Monitores
PROGRAMACIÓN CONCURRENTE Tema 5 Monitores 1 Indice Definición de los monitores Sincronización condicional usando monitores Algunos problemas con monitores 2 Problemas de las regiones críticas condicionales
Más detallesPROGRAMACION CONCURRENTE
PROGRAMACION CONCURRENTE II.3 Sincronización basada en memoria compartida: Semáforos J.M. Drake 1 Procesos concurrentes y memoria compartida. Si los diferentes procesos de un programa concurrente tienen
Más detalles2 Control de procesos y sincronización
2 Control de procesos y sincronización En los sistemas multiprogramados se define el proceso como entidad representante de la ejecución de un programa en un determinado contexto. Aunque hoy en día se ha
Más detallesTEMA 7: Ficheros. TEMA 7: Ficheros. 7.1.-Concepto de fichero
TEMA 7: Ficheros 7.1.-Concepto de fichero Todas las estructuras de datos que hemos visto hasta ahora utilizan memoria principal. Esto tiene dos limitaciones importantes: 1. Los datos desaparecen cuando
Más detallesThreads en Linux. Definición de thread. Thread implementado en Linux. Creando un thread en Linux. Ing. Marcelo Doallo Threads en Linux 1/9
Threads en Linux Definición de thread Es un mecanismo por el cual un programa puede hacer mas de una cosa al mismo tiempo. Como los procesos, los threads parecen correr simultáneamente; pero hay que tener
Más detallesTema 3. Monitores Programación Concurrente
Tema 3. Monitores Programación Concurrente Depto. de Lenguajes y Sistemas Informáticos Universidad de Granada Contenidos 1. Concepto de Monitor 1.1. Fundamento teórico de los monitores 1.2. Sintaxis de
Más detallesReceta general para resolver problemas de sincronización con semáforos
Receta general para resolver problemas de sincronización con semáforos La primera vez que te enfrentas a la tarea de implementar una solución a un problema de sincronización entre procesos, es normal que
Más detallesPráctico 2. Sincronización
Práctico 2. Sincronización 1. Dena a) Tareas b) Prioridades jas y dinámicas 2. Crear dos threads con prioridades jas iguales que impriman sucesivamente por la salida estándar, las palabras "Tiempo" y "Real"
Más detallesProcesos Definición y Estados
Procesos Definición y Estados Profesorado de Informática CeRP del Suroeste, Uruguay Contenidos Qué es un proceso Estructuras de datos para gestionar procesos API para trabajar con procesos Hilos (threads).
Más detalles7. Programación Concurrente
7. Programación Concurrente 1. Qué es la programación concurrente? Se conoce por programación concurrente a la rama de la informática que trata de las técnicas de programación que se usan para expresar
Más detallesSistemas Operativos Practica 1: procesos y concurrencia.
Sistemas Operativos Practica 1: procesos y concurrencia. Objetivos: Introducir al alumno a los conceptos de programa, concurrencia, paralelismo y proceso o tarea. Manejo del concepto de concurrencia haciendo
Más detallesUniversidad Autónoma del Estado de Hidalgo Instituto de Ciencias Básicas e Ingeniería Área Académica de Computación y Electrónica
Universidad Autónoma del Estado de Hidalgo Instituto de Ciencias Básicas e Ingeniería Área Académica de Computación y Electrónica Licenciatura en Sistemas Computacionales Sistemas Operativos Docente: M.G.A.
Más detallesSegundo control de teoría
JUSTIFICA TODAS LAS RESPUESTAS. UNA RESPUESTA SIN JUSTIFICAR SE CONSIDERA INVALIDA EJERCICIO 1: Preguntas cortas (2 puntos) 1) Qué es el superbloque de un sistema de ficheros? qué tipo de información podemos
Más detallesEjercicio 1. Teoría [2,5 puntos]:
ATENCIÓN: Dispone de 3 horas para realizar la prueba. Ejercicio 1. Teoría [2,5 puntos]: Pregunta 1. Cuándo entra un proceso en estado zombie? A.- Cuando muere su padre y él no ha terminado todavía. B.-
Más detallesSOLUCION EXAMEN junio 2006
SOLUCION EXAMEN junio 2006 1. Explique razonadamente si las siguientes afirmaciones son verdaderas o falsas: I) (1 p) En UNIX únicamente se distinguen dos tipos de procesos: los procesos de usuario y los
Más detallesProgramación de Sistemas de Tiempo Real
Tema 3 Programación de Sistemas de Tiempo Real Los Sistemas Informáticos más complejos que se emplean para la programación de Tiempo Real suelen compaginar tareas críticas de control, con tareas acríticas
Más detallesProgramación I Funciones
1 Funciones Iván Cantador 2 Funciones: definición, sintaxis, ejemplos (I) Una funciónes un bloque de sentencias identificado con un nombre que se ejecutan de manera secuencial ofreciendo una funcionalidad
Más detallesSISTEMAS OPERATIVOS I (Sistemas) / SISTEMAS OPERATIVOS (Gestión) septiembre 2009
SISTEMAS OPERATIVOS I (Sistemas) / SISTEMAS OPERATIVOS (Gestión) septiembre 2009 4. (2 p) Dos procesos A y B se ejecutan concurrentemente en un determinado sistema. El proceso A ejecuta unas tareas ( Tareas
Más detallesPráctica 8: Barreras
Arquitectura y Tecnología de Computadores 14 de febrero de 2014 Objetivos Aprender a utilizar las variables condición y las barreras de la biblioteca Pthreads. Diseñar e implementar una barrera: Barrera
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 detalles- Bajo que condiciones el algoritmo de planifiación de procesos FIFO (FCFS) resultaría en el tiempo de respuesta promedio más pequeño?
Sistemas Operativos. Grado Ingeniería Informática. TGR-2.1 Procesos. Noviembre 2014 Problemas para hacer en clase FIFO cpu C A 1. Dos procesos A y B tienen una ráfaga de CPU de 50 ms y un proceso C tiene
Más detallesSincronización de Procesos. Módulo 6. Departamento de Ciencias e Ingeniería de la Computación Universidad Nacional del Sur. Sincronización de Procesos
Sincronización de Procesos Módulo 6 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 La Solución
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 detallesSistemas Operativos I Manual de prácticas
Sistemas Operativos I Manual de prácticas Grupo de Sistemas Operativos (DSIC/DISCA) Práctica 4: Programación con hilos OBJETIVOS DE LA PRÁCTICA...2 ANTES DE EMPEZAR......2 PARTE 1: HOLA MUNDO CONCURRENTE...3
Más detallesUnidad IV: Programación concurrente (MultiHilos) 4.1. Concepto de hilo
Unidad IV: Programación concurrente (MultiHilos) 4.1. Concepto de hilo Hilo (theread) llamado también proceso ligero o subproceso, es la unidad de ejecución de un proceso y esta asociado con una secuencia
Más detallesMemoria compartida y semáforos r/w. La página del manual que podría servir para describir estas funciones es la siguiente:
(3 ptos) Memoria Compartida y Semáforos R/W 1. Objetivo En esta práctica se pretende crear una librería que dé la funcionalidad de un semáforo para resolver problemas con múltiples lectores y escritores
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 detallesEl lenguaje de Programación C. Fernando J. Pereda <ferdy@gentoo.org>
El lenguaje de Programación C Fernando J. Pereda Por qué aprender C? Portable y muy extendido Estándar (C89, C99) El lenguaje de los sistemas Un lenguaje fácil (no, no es broma) Por
Más detallesPROGRAMACIÓN CONCURRENTE
PROGRAMACIÓN CONCURRENTE Lenguajes de Programación - Progr. Concurrente 1 Introducción El concepto fundamental de la programación concurrente es la noción de Proceso. Proceso: Cálculo secuencial con su
Más detallesLlamadas al Sistema. Laboratorio de Arquitectura de Ordenadores
Llamadas al Sistema Laboratorio de Arquitectura de Ordenadores Índice Introducción Procesos Señales Sistema de ficheros Bibliografía 2 Introducción Llamadas al Sistema: Un API compuesto por una serie de
Más detallesGestión de procesos en UNIX
PROCESOS UNIX Gestión de procesos en UNIX Cada proceso sólo puede tener un flujo: el concepto proceso engloba todo Dos llamadas implicadas en la creación de procesos crear proceso cargar programa La relación
Más detallesTema 1: Programación Multiproceso. Curso
Tema 1: Programación Multiproceso. Curso 2012-2013 1 Patricia Hurtado Sayas Índice de contenidos: 1. Elementos funcionales de un SI. Repaso. 2. Concepto de Proceso o Tarea. 1. PCB, Bloque de Control de
Más detallesConcurrencia entre Procesos.
Concurrencia entre Procesos. Sistemas Operativos Tema 3. 1 Procesamiento concurrente. Procesamiento concurrente: base de los sistemas operativos modernos (multiprogramados): Un conjunto de procesos que
Más detallesSINCRONIZACIÓN DE PROCESOS
SINCRONIZACIÓN DE PROCESOS 1 Introducción Los procesos acceden a datos o recursos compartidos El acceso puede provocar que el estado final de los datos no sea correcto, generando incoherencias debido a
Más detallesSistemas Operativos. 10 de febrero de Nombre Apellidos. DNI Titulación Grupo.
Sistemas Operativos. 10 de febrero de 2006 Nombre Apellidos. DNI Titulación Grupo. TEORÍA 1. (Ficheros) 2 puntos a) Describa qué son y cómo se implementan los enlaces simbólicos y físicos en un sistema
Más detalles4.6.- Integridad: Control de concurrencia.
4.6.- Integridad: Control de concurrencia. 4.6.1.- Introducción 4.6.2.- Técnicas de Bloqueo. 4.6.2.1.- Bloqueo (variable cerrojo) Tipos, protocolos Problemas. Interbloqueo Granularidad 4.6.2.2.- Marcas
Más detallesLección 10: Ejemplos de programación con semáforos
Lección 10: Ejemplos de programación con semáforos El problema de la cena de los filósofos El problema de los lectores y escritores Ejercicios Gestión de concurrencia mediante paso de testigo (implementación
Más detallesIntroducción a Sistemas Operativos: Ficheros
Introducción a Sistemas Operativos: Ficheros Clips Fr ancisco J Ballesteros 1. Entrada/Salida Es importante saber cómo utilizar ficheros. En UNIX, es aún más importante dado que gran parte de los recursos,
Más detallesTodo programa en 'C' consta de una o más funciones, una de las cuales se llama main.
LENGUAJE C CARACTERISTICAS DEL LENGUAJE 'C' El lenguaje 'C' se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan
Más detallesCAPÍTULO 3. PROCESOS VS. HILOS
CAPÍTULO 3. PROCESOS VS. HILOS 3.1 Primitivas de sincronización en Java Java no tiene semáforos como primitivas de sincronización. Sin embargo, proporciona otras primitivas diferentes con las cuales sí
Más detallesEjercicios de Hilos. Índice
Índice 1 Creación de hilos (0.5 puntos)...2 2 Prioridades (0.5 puntos)... 2 3 Productor/Consumidor (1 punto)...2 4 Pool de hilos (1 punto)... 3 1. Creación de hilos (0.5 puntos) En la clase Ej1 se crean
Más detallesSucesos asíncronos. dit. dit. Juan Antonio de la Puente DIT/UPM UPM UPM
dit dit UPM UPM Sucesos asíncronos Juan Antonio de la Puente DIT/UPM Transparencias basadas en el capítulo 10del libro de A. Burns y A. Wellings Real Time Systems and Programming Languages, 3ª edición
Más detallesEsquema de un programa en C: bloques básicos
Esquema de un programa en C: bloques básicos // Incluimos los ficheros de cabecera que necesitemos. // Esto es un comentario #include #include // Si queremos definir alguna constante,
Más detallesAdministración de procesos: Primitivas de sincronización
Administración de procesos: Primitivas de sincronización Facultad de Ingeniería, UNAM Instituto de Investigaciones Económicas, UNAM Administración de procesos: Índice Introducción a la concurrencia 1 Introducción
Más detallesSistemas Operativos. Pedro Cabalar TEMA III. PROCESOS. Depto. de Computación Universidade da Coruña
Sistemas Operativos Pedro Cabalar Depto. de Computación Universidade da Coruña TEMA III. PROCESOS. P. Cabalar Sistemas( Operativos Depto. de Computación Universidade Tema da Coruña III. Procesos ) 1 /
Más detallesComunicación y Sincronización con Monitores Resumen del Tema
Notas de clase de Programación Concurrente Comunicación y Sincronización con Monitores Resumen del Tema Dpto de Lenguajes y Ciencias de la Computación Universidad de Málaga María del Mar Gallardo Melgarejo
Más detallesMONITORES EN JAVA. Antonio Tomeu Control de la Concurrencia en Java: API Estándar
MONITORES EN JAVA Un monitor es un objeto que implementa acceso bajo e.m. a todos sus métodos, y provee sincronización En Java, son objetos de una clase cuyos métodos públicos son todos synchronized Un
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 detalles